@memlab/core 1.0.0

package/dist/lib/HeapParser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @lightSyntaxTransform
+ * @format
+ */
+import type { IHeapSnapshot } from './Types';
+declare function getNodeIdsFromFile(file: string, _options?: {}): Promise<Set<number>>;
+declare function parse(file: string, options?: {}): Promise<IHeapSnapshot>;
+declare const _default: {
+    getNodeIdsFromFile: typeof getNodeIdsFromFile;
+    parse: typeof parse;
+};
+export default _default;
+//# sourceMappingURL=HeapParser.d.ts.map

package/dist/lib/HeapParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapParser.d.ts","sourceRoot":"","sources":["../../src/lib/HeapParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAEV,aAAa,EAGd,MAAM,SAAS,CAAC;AAyCjB,iBAAe,kBAAkB,CAC/B,IAAI,EAAE,MAAM,EAEZ,QAAQ,KAAK,GACZ,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAatB;AA+CD,iBAAe,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC,CAKvE;;;;;AAED,wBAGE"}

package/dist/lib/HeapParser.js

@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @lightSyntaxTransform
+ * @format
+ */
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Config_1 = __importDefault(require("./Config"));
+const Console_1 = __importDefault(require("./Console"));
+const StringLoader_1 = __importDefault(require("./StringLoader"));
+const HeapSnapshot_1 = __importDefault(require("./heap-data/HeapSnapshot"));
+// ----------- utility and parsing functions -----------
+function getSnapshotMetaData(content) {
+    function getSignatureIndex(signature) {
+        const idx = content.indexOf(signature);
+        if (idx < 0) {
+            throw 'heap parsing: meta data parsing error';
+        }
+        return idx;
+    }
+    const startSignature = '"snapshot":';
+    const startIdx = getSignatureIndex(startSignature) + startSignature.length;
+    const endSignature = '"nodes":';
+    const endIdx = getSignatureIndex(endSignature);
+    const metaContent = content.slice(startIdx, endIdx).trim().slice(0, -1);
+    return JSON.parse(metaContent);
+}
+const nums = Object.create(null);
+for (let i = 0; i < 10; i++) {
+    nums[`${i}`] = i;
+}
+function loadSnapshotMetaDataFromFile(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const content = yield StringLoader_1.default.readFile(file, {
+            startSignature: '"snapshot":',
+            endSignature: '"nodes":',
+            inclusive: true,
+        });
+        return getSnapshotMetaData(content);
+    });
+}
+function getNodeIdsFromFile(file, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const snapshotInfo = yield loadSnapshotMetaDataFromFile(file);
+        const nodes = yield StringLoader_1.default.readFileAndExtractTypedArray(file, 'nodes');
+        const ids = new Set();
+        const nodeFields = snapshotInfo.meta.node_fields;
+        const nodeFieldCount = nodeFields.length;
+        const idOffset = nodeFields.indexOf('id');
+        let valueIndex = 0;
+        while (valueIndex < nodes.length) {
+            ids.add(nodes[valueIndex + idOffset]);
+            valueIndex += nodeFieldCount;
+        }
+        return ids;
+    });
+}
+function parseFile(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [nodes, edges, locations, content] = yield Promise.all([
+            StringLoader_1.default.readFileAndExtractTypedArray(file, 'nodes'),
+            StringLoader_1.default.readFileAndExtractTypedArray(file, 'edges'),
+            StringLoader_1.default.readFileAndExtractTypedArray(file, 'locations'),
+            StringLoader_1.default.readFileAndExcludeTypedArray(file, [
+                'nodes',
+                'edges',
+                'locations',
+            ]),
+        ]);
+        const snapshot = JSON.parse(content);
+        snapshot.nodes = nodes;
+        snapshot.edges = edges;
+        snapshot.locations = locations;
+        return snapshot;
+    });
+}
+// auto detect and set JS snapshot's engine type
+function identifyAndSetEngine(snapshot) {
+    if (Config_1.default.specifiedEngine) {
+        if (Config_1.default.verbose) {
+            Console_1.default.lowLevel(`JS snapshot engine is manually set to be ${Config_1.default.jsEngine}`);
+        }
+        return; // skip if engine type is manually set
+    }
+    Console_1.default.overwrite('identifying snapshot engine...');
+    let engine = 'v8';
+    snapshot.nodes.forEach((node) => {
+        if (node.type === 'object' && node.name.startsWith('Object(')) {
+            engine = 'hermes';
+            return false;
+        }
+    });
+    if (Config_1.default.verbose) {
+        Console_1.default.lowLevel(`detect and set JS snapshot engine: ${engine}`);
+    }
+    Config_1.default.jsEngine = engine;
+}
+function parse(file, options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const snapshot = yield parseFile(file);
+        const ret = new HeapSnapshot_1.default(snapshot, options);
+        identifyAndSetEngine(ret);
+        return ret;
+    });
+}
+exports.default = {
+    getNodeIdsFromFile,
+    parse,
+};

package/dist/lib/InternalValueSetter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+export declare abstract class InternalValueSetter<T> {
+    fillIn(_module: T): T;
+}
+export declare function setInternalValue<T>(value: T, callerFilePath: string, internalFolderName: string): T;
+//# sourceMappingURL=InternalValueSetter.d.ts.map

package/dist/lib/InternalValueSetter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InternalValueSetter.d.ts","sourceRoot":"","sources":["../../src/lib/InternalValueSetter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,8BAAsB,mBAAmB,CAAC,CAAC;IAEzC,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC;CAGtB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,CAAC,EACR,cAAc,EAAE,MAAM,EACtB,kBAAkB,EAAE,MAAM,GACzB,CAAC,CAmBH"}

package/dist/lib/InternalValueSetter.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setInternalValue = exports.InternalValueSetter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class InternalValueSetter {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    fillIn(_module) {
+        throw new Error('InternalValueSetter.fillIn is not implemented');
+    }
+}
+exports.InternalValueSetter = InternalValueSetter;
+function setInternalValue(value, callerFilePath, internalFolderName) {
+    const callerDir = path_1.default.dirname(callerFilePath);
+    const callerFile = path_1.default.basename(callerFilePath);
+    const internalDir = path_1.default.join(callerDir, internalFolderName);
+    const internalModulePath = path_1.default.join(internalDir, callerFile);
+    if (!fs_1.default.existsSync(internalModulePath)) {
+        return value;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const module = require(internalModulePath);
+    const Constructor = typeof module.default === 'function' ? module.default : module;
+    const setter = new Constructor();
+    if (typeof setter.fillIn !== 'function') {
+        return value;
+    }
+    const valueSetter = setter;
+    return valueSetter.fillIn(value);
+}
+exports.setInternalValue = setInternalValue;

package/dist/lib/NodeHeap.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { AnyValue, IHeapSnapshot } from './Types';
+declare type AnyObject = Record<AnyValue, AnyValue>;
+export declare function tagObject(o: AnyObject, tag: string): AnyObject;
+export declare function dumpNodeHeapSnapshot(): string;
+export declare function getCurrentNodeHeap(): Promise<IHeapSnapshot>;
+export {};
+//# sourceMappingURL=NodeHeap.d.ts.map

package/dist/lib/NodeHeap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeHeap.d.ts","sourceRoot":"","sources":["../../src/lib/NodeHeap.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,QAAQ,EAAE,aAAa,EAAC,MAAM,SAAS,CAAC;AAQrD,aAAK,SAAS,GAAG,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAU5C,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAM9D;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAO7C;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,aAAa,CAAC,CASjE"}

package/dist/lib/NodeHeap.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentNodeHeap = exports.dumpNodeHeapSnapshot = exports.tagObject = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const v8_1 = __importDefault(require("v8"));
+const FileManager_1 = __importDefault(require("./FileManager"));
+const Utils_1 = __importDefault(require("./Utils"));
+class MemLabTaggedStore {
+    constructor() {
+        this.taggedObjects = Object.create(null);
+    }
+}
+const store = new MemLabTaggedStore();
+function tagObject(o, tag) {
+    if (!store.taggedObjects[tag]) {
+        store.taggedObjects[tag] = new WeakSet();
+    }
+    store.taggedObjects[tag].add(o);
+    return o;
+}
+exports.tagObject = tagObject;
+function dumpNodeHeapSnapshot() {
+    const file = path_1.default.join(FileManager_1.default.generateTmpHeapDir(), `nodejs.heapsnapshot`);
+    v8_1.default.writeHeapSnapshot(file);
+    return file;
+}
+exports.dumpNodeHeapSnapshot = dumpNodeHeapSnapshot;
+function getCurrentNodeHeap() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = dumpNodeHeapSnapshot();
+        const snapshot = yield Utils_1.default.getSnapshotFromFile(file, {
+            buildNodeIdIndex: true,
+        });
+        fs_extra_1.default.unlink(file, () => {
+            // do nothing
+        });
+        return snapshot;
+    });
+}
+exports.getCurrentNodeHeap = getCurrentNodeHeap;

package/dist/lib/ProcessManager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { Command, Optional } from './Types';
+declare type Options = {
+    msg?: string;
+    processLimit?: number;
+};
+declare class ProcessManager {
+    private procLimit;
+    private nProc;
+    start(nextCommand: () => Optional<Command>, options?: Options): void;
+    private init;
+    private hasFreeProcess;
+    private freeProcess;
+    private runInProcess;
+}
+export default ProcessManager;
+//# sourceMappingURL=ProcessManager.d.ts.map

package/dist/lib/ProcessManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessManager.d.ts","sourceRoot":"","sources":["../../src/lib/ProcessManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,OAAO,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAM/C,aAAK,OAAO,GAAG;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAIF,cAAM,cAAc;IAClB,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,KAAK,CAAK;IAGX,KAAK,CACV,WAAW,EAAE,MAAM,QAAQ,CAAC,OAAO,CAAC,EACpC,OAAO,GAAE,OAAY,GACpB,IAAI;IAeP,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,YAAY;CAmBrB;AAED,eAAe,cAAc,CAAC"}

package/dist/lib/ProcessManager.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Console_1 = __importDefault(require("./Console"));
+const child_process_1 = __importDefault(require("child_process"));
+const os_1 = __importDefault(require("os"));
+const DEFAULT_PROCESS_LIMIT = 1;
+class ProcessManager {
+    constructor() {
+        this.procLimit = DEFAULT_PROCESS_LIMIT;
+        this.nProc = 0;
+    }
+    // 1. periodically check for available free process
+    // 2. start commands in process until all tasks are completed
+    start(nextCommand, options = {}) {
+        this.init(options);
+        const timer = setInterval(() => {
+            if (!this.hasFreeProcess()) {
+                return;
+            }
+            const cmd = nextCommand();
+            // if next command is empty, stop the loop
+            if (!cmd) {
+                return clearInterval(timer);
+            }
+            this.runInProcess(...cmd);
+        }, 100);
+    }
+    init(options = {}) {
+        this.procLimit = options.processLimit
+            ? options.processLimit
+            : (os_1.default.cpus().length / 9) | 0;
+    }
+    hasFreeProcess() {
+        return this.nProc < this.procLimit;
+    }
+    freeProcess() {
+        this.nProc--;
+    }
+    runInProcess(cmd, args, options = {}) {
+        if (options.msg) {
+            Console_1.default.lowLevel(options.msg);
+        }
+        const str = [cmd, ...args].join(' ');
+        this.nProc++;
+        const proc = child_process_1.default.spawn(cmd, args);
+        proc.on('exit', code => {
+            Console_1.default.lowLevel(`done: ${str}`);
+            if (code !== 0) {
+                Console_1.default.error(`fail: ${str}`);
+            }
+            this.freeProcess();
+        });
+    }
+}
+exports.default = ProcessManager;

package/dist/lib/Serializer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import { E2EStepInfo, HeapNodeIdSet, IHeapEdge, IHeapNode, IHeapSnapshot, ISerializedInfo, LeakTracePathItem, Nullable } from './Types';
+declare type JSONifyArgs = {
+    leakedIdSet?: Set<number>;
+    nodeIdsInSnapshots?: Array<Set<number>>;
+};
+declare function JSONifyPath(path: LeakTracePathItem, _snapshot: IHeapSnapshot, args: JSONifyArgs): Nullable<ISerializedInfo>;
+declare type SummarizeOptions = {
+    compact?: boolean;
+    color?: boolean;
+    progress?: number;
+    abstract?: boolean;
+    depth?: number;
+    excludeKeySet?: HeapNodeIdSet;
+};
+declare function summarizeNodeShape(node: IHeapNode, options?: SummarizeOptions): string;
+declare type UnboundedObjectInfo = {
+    id: number;
+    name: string;
+    node: IHeapNode;
+    type: string;
+    history: number[];
+};
+declare function summarizeUnboundedObjects(unboundedObjects: UnboundedObjectInfo[], options?: SummarizeOptions): string;
+declare function summarizeUnboundedObjectsToCSV(unboundedObjects: UnboundedObjectInfo[]): string;
+declare function summarizeTabsOrder(tabsOrder: E2EStepInfo[], options?: SummarizeOptions): string;
+declare function summarizeNodeName(node: IHeapNode, options: SummarizeOptions): string;
+declare function summarizeEdgeName(edge: IHeapEdge, options?: SummarizeOptions): string;
+declare function summarizePath(pathArg: LeakTracePathItem, nodeIdInPaths: Set<number>, snapshot: IHeapSnapshot, options?: SummarizeOptions): string;
+declare const _default: {
+    JSONifyPath: typeof JSONifyPath;
+    summarizeEdgeName: typeof summarizeEdgeName;
+    summarizeNodeName: typeof summarizeNodeName;
+    summarizeNodeShape: typeof summarizeNodeShape;
+    summarizePath: typeof summarizePath;
+    summarizeTabsOrder: typeof summarizeTabsOrder;
+    summarizeUnboundedObjects: typeof summarizeUnboundedObjects;
+    summarizeUnboundedObjectsToCSV: typeof summarizeUnboundedObjectsToCSV;
+};
+export default _default;
+//# sourceMappingURL=Serializer.d.ts.map

package/dist/lib/Serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serializer.d.ts","sourceRoot":"","sources":["../../src/lib/Serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,OAAO,EACL,WAAW,EACX,aAAa,EACb,SAAS,EACT,SAAS,EACT,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,QAAQ,EAET,MAAM,SAAS,CAAC;AAajB,aAAK,WAAW,GAAG;IACjB,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,kBAAkB,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACzC,CAAC;AAwYF,iBAAS,WAAW,CAClB,IAAI,EAAE,iBAAiB,EACvB,SAAS,EAAE,aAAa,EACxB,IAAI,EAAE,WAAW,GAChB,QAAQ,CAAC,eAAe,CAAC,CAkC3B;AA+ID,aAAK,gBAAgB,GAAG;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B,CAAC;AA6BF,iBAAS,kBAAkB,CACzB,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CASR;AAED,aAAK,mBAAmB,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,iBAAS,yBAAyB,CAChC,gBAAgB,EAAE,mBAAmB,EAAE,EACvC,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAcR;AAED,iBAAS,8BAA8B,CACrC,gBAAgB,EAAE,mBAAmB,EAAE,GACtC,MAAM,CAMR;AAiBD,iBAAS,kBAAkB,CACzB,SAAS,EAAE,WAAW,EAAE,EACxB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAuBR;AAED,iBAAS,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAI7E;AAoBD,iBAAS,iBAAiB,CACxB,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAeR;AAkBD,iBAAS,aAAa,CACpB,OAAO,EAAE,iBAAiB,EAC1B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,QAAQ,EAAE,aAAa,EACvB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CA2ER;;;;;;;;;;;AAED,wBASE"}