meminsight-core-publish 1.0.0

package/dist/types/OhosTypes.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeapInfos = exports.HeapFileInfo = exports.UrlInfo = exports.AppInfo = exports.DeviceInfo = exports.OsInfo = void 0;
+/**
+ * os info
+ */
+class OsInfo {
+    constructor(name, version) {
+        this.type = "os";
+        this.name = name || "ohos";
+        this.version = version;
+    }
+    toString() {
+        return `${this.type} ${this.name} ${this.version}`;
+    }
+}
+exports.OsInfo = OsInfo;
+/**
+ * device info
+ */
+class DeviceInfo {
+    constructor(deviceId) {
+        this.type = 'ohos-device';
+        this.deviceId = deviceId || '';
+    }
+    toString() {
+        return `${this.deviceId}`;
+    }
+}
+exports.DeviceInfo = DeviceInfo;
+/**
+ * app info
+ */
+class AppInfo {
+    constructor(name, pid, version) {
+        this.type = 'app';
+        this.name = name || '';
+        this.pid = pid;
+        this.version = version;
+    }
+    toString() {
+        return `${this.name}`;
+    }
+}
+exports.AppInfo = AppInfo;
+/**
+ * url info
+ */
+class UrlInfo {
+    constructor() {
+        this.type = 'url';
+    }
+    toString() {
+        return `${this.url}`;
+    }
+}
+exports.UrlInfo = UrlInfo;
+/**
+ * heap file info
+ */
+class HeapFileInfo {
+    constructor(path) {
+        this.type = 'heap';
+        this.createTime = 0; // create time
+        this.path = path;
+    }
+    toString() {
+        return `${this.name}:${this.path}`;
+    }
+}
+exports.HeapFileInfo = HeapFileInfo;
+/**
+ * heap infos
+ */
+class HeapInfos {
+    constructor(os, device, app, heapFile) {
+        this.osInfo = os;
+        this.deviceInfo = device;
+        this.appInfo = app;
+        this.heapFileInfo = heapFile;
+    }
+}
+exports.HeapInfos = HeapInfos;

package/dist/utils/Common.d.ts

@@ -0,0 +1,14 @@
+/**
+ * T != null
+ * @param value T instance
+ * @returns true if T instance is not null or undefined
+ */
+export declare function isDefined<T>(value: T | null | undefined): value is T;
+/**
+ * 格式化 Date 为指定字符串
+ * @param date 要格式化的日期（默认当前时间）
+ * @param format 格式模板：YYYY=年, MM=月, DD=日, HH=时, mm=分, ss=秒, SSS=毫秒
+ * @returns 格式化后的字符串
+ */
+export declare function formatDate(date: Date, format?: string): string;
+//# sourceMappingURL=Common.d.ts.map

package/dist/utils/Common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Common.d.ts","sourceRoot":"","sources":["../../src/utils/Common.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,IAAI,CAAC,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAE,MAAyB,GAAG,MAAM,CAqBhF"}

package/dist/utils/Common.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = isDefined;
+exports.formatDate = formatDate;
+/**
+ * T != null
+ * @param value T instance
+ * @returns true if T instance is not null or undefined
+ */
+function isDefined(value) {
+    return value != null;
+}
+/**
+ * 格式化 Date 为指定字符串
+ * @param date 要格式化的日期（默认当前时间）
+ * @param format 格式模板：YYYY=年, MM=月, DD=日, HH=时, mm=分, ss=秒, SSS=毫秒
+ * @returns 格式化后的字符串
+ */
+function formatDate(date, format = 'YYYYMMDDHHmmss') {
+    // 补零函数：确保数字为两位数（如 9 → 09）
+    const padZero = (num, length = 2) => num.toString().padStart(length, '0');
+    const year = date.getFullYear();
+    const month = padZero(date.getMonth() + 1); // 月份从 0 开始，需 +1
+    const day = padZero(date.getDate());
+    const hour = padZero(date.getHours());
+    const minute = padZero(date.getMinutes());
+    const second = padZero(date.getSeconds());
+    const millisecond = padZero(date.getMilliseconds(), 3); // 三位数毫秒
+    // 替换格式模板
+    return format
+        .replace('YYYY', year.toString())
+        .replace('MM', month)
+        .replace('DD', day)
+        .replace('HH', hour)
+        .replace('mm', minute)
+        .replace('ss', second)
+        .replace('SSS', millisecond);
+}

package/dist/utils/Finder.d.ts

@@ -0,0 +1,163 @@
+import { IHeapSnapshot, IHeapNode, IHeapEdge, Nullable, LeakTracePathItem } from "@memlab/core";
+/**
+ * 查找器
+ */
+export declare class Finder {
+    private static traceFinder;
+    /**
+     * 判断是否是指定名称属性的边
+     * @param edge 边
+     * @param propName 名称
+     * @returns true/false
+     */
+    static isPropEdgeWithName(edge: IHeapEdge, propName: string): boolean;
+    /**
+     * 判断是否是Proto属性的边
+     * @param edge 边
+     * @returns true/false
+     */
+    static isProtoPropEdge(edge: IHeapEdge): boolean;
+    /**
+     * 判断是否是hclass属性的边
+     * @param edge 边
+     * @returns true/false
+     */
+    static isHClassPropEdge(edge: IHeapEdge): boolean;
+    /**
+     * 共享内存类型
+     * 例举关键类型
+     */
+    static OOM_SHARED_TYPES: string[];
+    static STRING_UNIQUE_ID: string;
+    static isSharedHeapNode(node: IHeapNode): boolean;
+    static getSharedHeapNodesMap(snapshot: IHeapSnapshot): Map<string, Array<IHeapNode>>;
+    /**
+     * 获取所有shared heap节点的retained size大小总和
+     * @param snapshot heapsnapshot
+     */
+    static getSharedHeapNodeRetainedSize(snapshot: IHeapSnapshot): number;
+    /**
+     * 获取所有string类型对象的retained size大小总和
+     * @param snapshot heapsnapshot
+     * @returns retained size of shared heap string
+     */
+    static getStringRetainedSize(snapshot: IHeapSnapshot): number;
+    static isSharedHeapNodeId(snapshot: IHeapSnapshot, nodeId: number): boolean;
+    /**
+     * 是否是GCRoot节点
+     * @param node 目标节点
+     * @returns true/false
+     */
+    static isGCRoot(targetNode: IHeapNode): boolean;
+    /**
+     * 是否是Distance为1的节点
+     * @param targetNode 目标节点
+     * @returns true/false
+     */
+    static isEqualDistanceOne(targetNode: IHeapNode): boolean;
+    /**
+     * 查找指定ID的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeId 节点ID
+     * @returns
+     */
+    static findNodeById(snapshot: IHeapSnapshot, nodeId: number): Nullable<IHeapNode>;
+    /**
+     * 查找满足过滤条件的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param filter 过滤器
+     * @returns IHeapNode Array
+     */
+    static findNodesByFilter(snapshot: IHeapSnapshot, filter: (node: IHeapNode) => boolean): Array<IHeapNode>;
+    /**
+     * 按过滤器和过滤条件查找节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param filter 过滤器
+     * @param condition 过滤条件
+     * @returns IHeapNode Array
+     */
+    static findNodesByFilterCondition(snapshot: IHeapSnapshot, filter: (node: IHeapNode, condition: any) => boolean, condition: any): Array<IHeapNode>;
+    /**
+     * 查找所有GCRoot节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @returns IHeapNode Array
+     */
+    static findGCRoots(snapshot: IHeapSnapshot): Array<IHeapNode>;
+    /**
+     * 查找Detached节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @returns IHeapNode Array
+     */
+    static findDetachedNodes(snapshot: IHeapSnapshot): Array<IHeapNode>;
+    /**
+     * 查找指定个数的Detached节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns IHeapNode Array
+     */
+    static findDetachedNodesByName(snapshot: IHeapSnapshot, nodeName: string): Array<IHeapNode>;
+    /**
+     * find nodes by distance from gc root
+     * @param snapshot snapshot
+     * @param distance distance <= 1
+     * @returns Array<IHeapNode>
+     */
+    static findNodesByDistanceOne(snapshot: IHeapSnapshot, includeGCRoot?: boolean): Array<IHeapNode>;
+    /**
+     * 查找指定节点名称的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns IHeapNode Array
+     */
+    static findNodesByName(snapshot: IHeapSnapshot, nodeName: string): Array<IHeapNode>;
+    /**
+     * 查找指定节点名称的节点，最大个数为
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @param count 查找对象个数（按节点id号排序）
+     * @param reverse 是否倒序查找
+     * @returns IHeapNode Array
+     */
+    static findNodesByNameCount(snapshot: IHeapSnapshot, nodeName: string, count: number): Array<IHeapNode>;
+    /**
+     *
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns
+     */
+    static findNodesByNameDistanceOne(snapshot: IHeapSnapshot, nodeName: string, includeGCRoot?: boolean): Array<IHeapNode>;
+    /**
+     * 查找指定节点的最短引用路径
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param targetNode 节点对象
+     * @returns 引用链路径
+     */
+    static findShortestPathToGCRoot(snapshot: IHeapSnapshot, targetNode: IHeapNode): LeakTracePathItem | undefined;
+    /**
+     * 查找指定节点数组的所有最短引用路径
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param targetNodes 节点对象数组
+     * @returns 引用链路径数组
+     */
+    static findShortestPaths(snapshot: IHeapSnapshot, targetNodes: IHeapNode[]): Array<LeakTracePathItem>;
+    /**
+    * 获取堆节点的最短路径
+    * @param node 堆节点
+    * @returns 最短路径的节点名称数组
+    * @example
+    */
+    static getShortestPath(node: IHeapNode): [number[], string[], number];
+    /**
+  * 获取节点模块名（兼容5.x & 6.0）
+  * @param name 节点名称
+  * @returns module name
+  */
+    static getModuleName(name: string): string;
+    /**
+     * 获取节点Class名（兼容5.x & 6.0）
+     * @param name 节点名称
+     * @returns class name
+     */
+    static getClassName(name: string): string;
+}
+//# sourceMappingURL=Finder.d.ts.map

package/dist/utils/Finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Finder.d.ts","sourceRoot":"","sources":["../../src/utils/Finder.ts"],"names":[],"mappings":"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"}

package/dist/utils/Finder.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Finder = void 0;
+const core_1 = require("@memlab/core");
+/**
+ * 查找器
+ */
+class Finder {
+    /**
+     * 判断是否是指定名称属性的边
+     * @param edge 边
+     * @param propName 名称
+     * @returns true/false
+     */
+    static isPropEdgeWithName(edge, propName) {
+        return edge.type === 'property' && edge.name_or_index === propName;
+    }
+    /**
+     * 判断是否是Proto属性的边
+     * @param edge 边
+     * @returns true/false
+     */
+    static isProtoPropEdge(edge) {
+        return edge.type === 'property' && edge.name_or_index === 'Proto';
+    }
+    /**
+     * 判断是否是hclass属性的边
+     * @param edge 边
+     * @returns true/false
+     */
+    static isHClassPropEdge(edge) {
+        return edge.type === 'property' && edge.name_or_index === 'hclass';
+    }
+    static isSharedHeapNode(node) {
+        // String 类对象属于 shared heap
+        if (node.isString) {
+            return true;
+        }
+        // 共享内存类型与节点名称匹配的
+        if (Finder.OOM_SHARED_TYPES.includes(node.name)) {
+            return true;
+        }
+        // 先判断 Proto
+        let protoEdge = node.findAnyReference((edge) => { return Finder.isProtoPropEdge(edge); });
+        if (protoEdge) {
+            // 通过 proto 查找是否是 shared heap
+            if (this.OOM_SHARED_TYPES.includes(protoEdge.toNode.name)) {
+                return true;
+            }
+            return this.isSharedHeapNode(protoEdge.toNode);
+        }
+        // 再判断 hclass
+        let hclassEdge = node.findAnyReference((edge) => { return this.isHClassPropEdge(edge); });
+        if (hclassEdge === null) {
+            return false;
+        }
+        return this.isSharedHeapNode(hclassEdge.toNode);
+    }
+    static getSharedHeapNodesMap(snapshot) {
+        let nodesMap = new Map();
+        snapshot.nodes.forEach((node) => {
+            if (Finder.isSharedHeapNode(node)) {
+                let tag = node.isString ? Finder.STRING_UNIQUE_ID : node.name;
+                let nodes = nodesMap.get(tag);
+                if (nodes === undefined) {
+                    nodes = new Array();
+                }
+                nodes.push(node);
+                nodesMap.set(tag, nodes);
+            }
+        });
+        return nodesMap;
+    }
+    /**
+     * 获取所有shared heap节点的retained size大小总和
+     * @param snapshot heapsnapshot
+     */
+    static getSharedHeapNodeRetainedSize(snapshot) {
+        let retained_size = 0;
+        snapshot.nodes.forEach((node) => {
+            if (Finder.isSharedHeapNode(node)) {
+                retained_size += node.retainedSize;
+            }
+        });
+        return retained_size;
+    }
+    /**
+     * 获取所有string类型对象的retained size大小总和
+     * @param snapshot heapsnapshot
+     * @returns retained size of shared heap string
+     */
+    static getStringRetainedSize(snapshot) {
+        let retained_size = 0;
+        snapshot.nodes.forEach((node) => {
+            if (node.isString) {
+                retained_size += node.retainedSize;
+            }
+        });
+        return retained_size;
+    }
+    static isSharedHeapNodeId(snapshot, nodeId) {
+        const node = snapshot.getNodeById(nodeId);
+        if (node === null) {
+            return false;
+        }
+        return Finder.isSharedHeapNode(node);
+    }
+    /**
+     * 是否是GCRoot节点
+     * @param node 目标节点
+     * @returns true/false
+     */
+    static isGCRoot(targetNode) {
+        return targetNode.numOfReferrers === 0;
+    }
+    /**
+     * 是否是Distance为1的节点
+     * @param targetNode 目标节点
+     * @returns true/false
+     */
+    static isEqualDistanceOne(targetNode) {
+        let result = false;
+        targetNode.pathEdge;
+        targetNode.referrers.forEach((referrer) => {
+            if (referrer.fromNode.numOfReferrers === 0) {
+                result = true;
+            }
+        });
+        return result;
+    }
+    /**
+     * 查找指定ID的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeId 节点ID
+     * @returns
+     */
+    static findNodeById(snapshot, nodeId) {
+        return snapshot.getNodeById(nodeId);
+    }
+    /**
+     * 查找满足过滤条件的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param filter 过滤器
+     * @returns IHeapNode Array
+     */
+    static findNodesByFilter(snapshot, filter) {
+        const result = new Array();
+        snapshot.nodes.forEach((node) => {
+            if (filter(node)) {
+                result.push(node);
+            }
+        });
+        return result;
+    }
+    /**
+     * 按过滤器和过滤条件查找节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param filter 过滤器
+     * @param condition 过滤条件
+     * @returns IHeapNode Array
+     */
+    static findNodesByFilterCondition(snapshot, filter, condition) {
+        const result = new Array();
+        snapshot.nodes.forEach((node) => {
+            if (filter(node, condition)) {
+                result.push(node);
+            }
+        });
+        return result;
+    }
+    /**
+     * 查找所有GCRoot节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @returns IHeapNode Array
+     */
+    static findGCRoots(snapshot) {
+        let filter = (node) => Finder.isGCRoot(node);
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+    /**
+     * 查找Detached节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @returns IHeapNode Array
+     */
+    static findDetachedNodes(snapshot) {
+        let filter = (node) => node.is_detached;
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+    /**
+     * 查找指定个数的Detached节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns IHeapNode Array
+     */
+    static findDetachedNodesByName(snapshot, nodeName) {
+        const result = new Array();
+        snapshot.nodes.forEach((node) => {
+            if (node.is_detached && node.name === nodeName) {
+                result.push(node);
+            }
+        });
+        return result;
+    }
+    /**
+     * find nodes by distance from gc root
+     * @param snapshot snapshot
+     * @param distance distance <= 1
+     * @returns Array<IHeapNode>
+     */
+    static findNodesByDistanceOne(snapshot, includeGCRoot = false) {
+        let filter = (node) => {
+            return (includeGCRoot && Finder.isGCRoot(node)) || Finder.isEqualDistanceOne(node);
+        };
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+    /**
+     * 查找指定节点名称的节点
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns IHeapNode Array
+     */
+    static findNodesByName(snapshot, nodeName) {
+        let filter = (node) => {
+            return node.name == nodeName;
+        };
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+    /**
+     * 查找指定节点名称的节点，最大个数为
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @param count 查找对象个数（按节点id号排序）
+     * @param reverse 是否倒序查找
+     * @returns IHeapNode Array
+     */
+    static findNodesByNameCount(snapshot, nodeName, count) {
+        const result = new Array();
+        let nodeCount = 0;
+        snapshot.nodes.forEach((node) => {
+            if ((node.name == nodeName) && (nodeCount < count)) {
+                result.push(node);
+                nodeCount += 1;
+            }
+        });
+        return result;
+    }
+    /**
+     *
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param nodeName 节点名称
+     * @returns
+     */
+    static findNodesByNameDistanceOne(snapshot, nodeName, includeGCRoot = false) {
+        let filter = (node) => {
+            return (node.name === nodeName)
+                && ((includeGCRoot && Finder.isGCRoot(node)) || Finder.isEqualDistanceOne(node));
+        };
+        return Finder.findNodesByFilter(snapshot, filter);
+    }
+    /**
+     * 查找指定节点的最短引用路径
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param targetNode 节点对象
+     * @returns 引用链路径
+     */
+    static findShortestPathToGCRoot(snapshot, targetNode) {
+        Finder.traceFinder.annotateShortestPaths(snapshot); // 标记最短路径
+        const optPath = Finder.traceFinder.getPathToGCRoots(snapshot, targetNode);
+        return optPath ? optPath : undefined;
+    }
+    /**
+     * 查找指定节点数组的所有最短引用路径
+     * @param snapshot 快照对象 IHeapSnapshot
+     * @param targetNodes 节点对象数组
+     * @returns 引用链路径数组
+     */
+    static findShortestPaths(snapshot, targetNodes) {
+        const result = new Array();
+        Finder.traceFinder.annotateShortestPaths(snapshot);
+        targetNodes.forEach(node => {
+            const optPath = Finder.traceFinder.getPathToGCRoots(snapshot, node);
+            if (optPath) {
+                result.push(optPath);
+            }
+        });
+        return result;
+    }
+    /**
+    * 获取堆节点的最短路径
+    * @param node 堆节点
+    * @returns 最短路径的节点名称数组
+    * @example
+    */
+    static getShortestPath(node) {
+        const shortestPathNodeIds = [];
+        const shortestPathStrings = [];
+        let distance = 0;
+        let shortestPathNode = node;
+        while (shortestPathNode && shortestPathNode.hasPathEdge) {
+            let edge = shortestPathNode.pathEdge;
+            if (edge) {
+                distance++;
+                shortestPathNodeIds.push(edge.fromNode.id);
+                shortestPathStrings.push(edge.fromNode.name);
+                shortestPathNode = edge.fromNode;
+            }
+        }
+        return [shortestPathNodeIds, shortestPathStrings, distance];
+    }
+    /**
+  * 获取节点模块名（兼容5.x & 6.0）
+  * @param name 节点名称
+  * @returns module name
+  */
+    static getModuleName(name) {
+        let nameSplit = name.split('#');
+        if (nameSplit.length > 1) {
+            // 6.0
+            return nameSplit[0];
+        }
+        // 5.x
+        return name.split(' ')[0];
+    }
+    /**
+     * 获取节点Class名（兼容5.x & 6.0）
+     * @param name 节点名称
+     * @returns class name
+     */
+    static getClassName(name) {
+        let regex = /^(.*?)\(line:\d+\).*?$/;
+        const match = regex.exec(name);
+        if (match) {
+            return match[1];
+        }
+        let regex5 = /^(.*?)\(.*?\)$/;
+        const match5 = regex5.exec(name);
+        if (match5) {
+            return match5[1];
+        }
+        return name;
+    }
+}
+exports.Finder = Finder;
+Finder.traceFinder = new core_1.TraceFinder();
+/**
+ * 共享内存类型
+ * 例举关键类型
+ */
+Finder.OOM_SHARED_TYPES = [
+    'js_shared_object',
+    'js_shared_array',
+    'js_shared_map',
+    'js_shared_set'
+];
+Finder.STRING_UNIQUE_ID = 'shared_heap_string_unique_id_0123456789';

package/dist/utils/Loader.d.ts

@@ -0,0 +1,30 @@
+import { IHeapSnapshot, AnyOptions } from "@memlab/core";
+/**
+ * Loader
+ */
+export declare class Loader {
+    static readonly DOMAIN = "HeapSnapshot";
+    static readonly TAG = "Loader";
+    /**
+     * 加载HeapSnapshot文件
+     * @param file 文件路径
+     * @param log 是否打印日志
+     * @returns IHeapSnapshot 对象
+     */
+    static loadFromFile(file: string, log?: boolean): Promise<IHeapSnapshot>;
+    /**
+     * 加载HeapSnapshot文件
+     * @param file 文件路径
+     * @param options 可选参数选项
+     * @param log 是否打印日志
+     * @returns IHeapSnapshot 对象
+     */
+    static loadFromFileOption(file: string, options: AnyOptions, log?: boolean): Promise<IHeapSnapshot>;
+    /**
+     * Heapsnapshot 多文件加载
+     * @param files 多文件路径集合
+     * @returns IHeapSnapshot 对象集合
+     */
+    static loadFromFiles(files: Array<string>): Promise<Array<IHeapSnapshot>>;
+}
+//# sourceMappingURL=Loader.d.ts.map

package/dist/utils/Loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loader.d.ts","sourceRoot":"","sources":["../../src/utils/Loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAS,UAAU,EAAE,MAAM,cAAc,CAAC;AAIhE;;GAEG;AACH,qBAAa,MAAM;IACf,gBAAuB,MAAM,kBAAkB;IAC/C,gBAAuB,GAAG,YAAY;IAEtC;;;;;OAKG;WACiB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,OAAe,GAAI,OAAO,CAAC,aAAa,CAAC;IAO7F;;;;;;OAMG;WACiB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAC/C,OAAO,EAAE,UAAU,EAAE,GAAG,GAAE,OAAe,GAAI,OAAO,CAAC,aAAa,CAAC;IAOvE;;;;OAIG;WACiB,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAI,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;CAQ1F"}