@depup/nx 22.5.4-depup.0

package/src/project-graph/nx-deps-cache.d.ts

@@ -0,0 +1,63 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import type { FileData, FileMap, ProjectGraph } from '../config/project-graph';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { ConfigurationSourceMaps } from './utils/project-configuration-utils';
+import { ProjectGraphErrorTypes } from './error-types';
+export interface FileMapCache {
+    version: string;
+    nxVersion: string;
+    pathMappings: Record<string, any>;
+    nxJsonPlugins: PluginData[];
+    pluginsConfig?: any;
+    fileMap: FileMap;
+    externalNodesHash?: string;
+}
+export declare const nxProjectGraph: string;
+export declare const nxFileMap: string;
+export declare const nxSourceMaps: string;
+export declare function ensureCacheDirectory(): void;
+export declare function readFileMapCache(): null | FileMapCache;
+export declare function readProjectGraphCache(minimumComputedAt?: number): null | ProjectGraph;
+export declare function readSourceMapsCache(): null | ConfigurationSourceMaps;
+export declare function createProjectFileMapCache(nxJson: NxJsonConfiguration<'*' | string[]>, packageJsonDeps: Record<string, string>, fileMap: FileMap, tsConfig: {
+    compilerOptions?: {
+        paths?: {
+            [p: string]: any;
+        };
+    };
+}, externalNodesHash: string): FileMapCache;
+export declare function writeCache(cache: FileMapCache, projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, errors: ProjectGraphErrorTypes[]): void;
+/**
+ * Writes the cache only if the on-disk cache file has been modified since
+ * this process last wrote it (i.e. an external process overwrote it), or
+ * if this process has never written the cache.
+ *
+ * Use this instead of writeCache() on hot paths where the same graph may
+ * be served multiple times without changing (e.g. the daemon responding
+ * to repeated client requests).
+ */
+export declare function writeCacheIfStale(cache: FileMapCache, projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, errors: ProjectGraphErrorTypes[]): void;
+export declare function shouldRecomputeWholeGraph(cache: FileMapCache, packageJsonDeps: Record<string, string>, projects: Record<string, ProjectConfiguration>, nxJson: NxJsonConfiguration, tsConfig: {
+    compilerOptions: {
+        paths: {
+            [k: string]: any;
+        };
+    };
+}, externalNodesHash: string): boolean;
+export type CachedFileData = {
+    nonProjectFiles: Record<string, FileData>;
+    projectFileMap: {
+        [project: string]: Record<string, FileData>;
+    };
+};
+export declare function extractCachedFileData(fileMap: FileMap, c: FileMapCache): {
+    filesToProcess: FileMap;
+    cachedFileData: CachedFileData;
+};
+type PluginData = {
+    name: string;
+    version: string;
+    options?: unknown;
+};
+export {};
+//# sourceMappingURL=nx-deps-cache.d.ts.map

package/src/project-graph/nx-deps-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-deps-cache.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/project-graph/nx-deps-cache.ts"],"names":[],"mappings":"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"}

package/src/project-graph/nx-deps-cache.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxSourceMaps = exports.nxFileMap = exports.nxProjectGraph = void 0;
+exports.ensureCacheDirectory = ensureCacheDirectory;
+exports.readFileMapCache = readFileMapCache;
+exports.readProjectGraphCache = readProjectGraphCache;
+exports.readSourceMapsCache = readSourceMapsCache;
+exports.createProjectFileMapCache = createProjectFileMapCache;
+exports.writeCache = writeCache;
+exports.writeCacheIfStale = writeCacheIfStale;
+exports.shouldRecomputeWholeGraph = shouldRecomputeWholeGraph;
+exports.extractCachedFileData = extractCachedFileData;
+const node_fs_1 = require("node:fs");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const cache_directory_1 = require("../utils/cache-directory");
+const fileutils_1 = require("../utils/fileutils");
+const versions_1 = require("../utils/versions");
+const error_types_1 = require("./error-types");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const logger_1 = require("../daemon/logger");
+exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.json');
+exports.nxFileMap = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'file-map.json');
+exports.nxSourceMaps = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'source-maps.json');
+function ensureCacheDirectory() {
+    try {
+        if (!(0, node_fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
+            (0, node_fs_1.mkdirSync)(cache_directory_1.workspaceDataDirectory, { recursive: true });
+        }
+    }
+    catch (e) {
+        /*
+         * @jeffbcross: Node JS docs recommend against checking for existence of directory immediately before creating it.
+         * Instead, just try to create the directory and handle the error.
+         *
+         * We ran into race conditions when running scripts concurrently, where multiple scripts were
+         * arriving here simultaneously, checking for directory existence, then trying to create the directory simultaneously.
+         *
+         * In this case, we're creating the directory. If the operation failed, we ensure that the directory
+         * exists before continuing (or raise an exception).
+         */
+        if (!(0, fileutils_1.directoryExists)(cache_directory_1.workspaceDataDirectory)) {
+            throw new Error(`Failed to create directory: ${cache_directory_1.workspaceDataDirectory}`);
+        }
+    }
+}
+function readFileMapCache() {
+    perf_hooks_1.performance.mark('read cache:start');
+    ensureCacheDirectory();
+    let data = null;
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxFileMap)) {
+            data = (0, fileutils_1.readJsonFile)(exports.nxFileMap);
+        }
+    }
+    catch (error) {
+        console.log(`Error reading '${exports.nxFileMap}'. Continue the process without the cache.`);
+        console.log(error);
+    }
+    perf_hooks_1.performance.mark('read cache:end');
+    perf_hooks_1.performance.measure('read cache', 'read cache:start', 'read cache:end');
+    return data ?? null;
+}
+function readProjectGraphCache(minimumComputedAt) {
+    perf_hooks_1.performance.mark('read project-graph:start');
+    ensureCacheDirectory();
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxProjectGraph)) {
+            const { computedAt, errors, ...projectGraphCache } = (0, fileutils_1.readJsonFile)(exports.nxProjectGraph);
+            if (minimumComputedAt &&
+                (!computedAt || computedAt < minimumComputedAt)) {
+                throw new error_types_1.StaleProjectGraphCacheError();
+            }
+            if (errors && errors.length > 0) {
+                if (!minimumComputedAt) {
+                    // If you didn't pass minimum computed at, we do not know if
+                    // the errors on the cached graph would be relevant to what you
+                    // are running. Prior to adding error handling here, the graph
+                    // would not have been written to the cache. As such, this matches
+                    // existing behavior of the public API.
+                    return null;
+                }
+                throw new error_types_1.ProjectGraphError(errors, projectGraphCache, readSourceMapsCache());
+            }
+            return projectGraphCache;
+        }
+        else {
+            return null;
+        }
+    }
+    catch (error) {
+        if (error instanceof error_types_1.StaleProjectGraphCacheError ||
+            error instanceof error_types_1.ProjectGraphError) {
+            throw error;
+        }
+        console.log(`Error reading '${exports.nxProjectGraph}'. Continue the process without the cache.`);
+        console.log(error);
+        return null;
+    }
+    finally {
+        perf_hooks_1.performance.mark('read project-graph:end');
+        perf_hooks_1.performance.measure('read cache', 'read project-graph:start', 'read project-graph:end');
+    }
+}
+function readSourceMapsCache() {
+    perf_hooks_1.performance.mark('read source-maps:start');
+    ensureCacheDirectory();
+    let data = null;
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxSourceMaps)) {
+            data = (0, fileutils_1.readJsonFile)(exports.nxSourceMaps);
+        }
+    }
+    catch (error) {
+        console.log(`Error reading '${exports.nxSourceMaps}'. Continue the process without the cache.`);
+        console.log(error);
+    }
+    perf_hooks_1.performance.mark('read source-maps:end');
+    perf_hooks_1.performance.measure('read cache', 'read source-maps:start', 'read source-maps:end');
+    return data ?? null;
+}
+function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig, externalNodesHash) {
+    const nxJsonPlugins = getNxJsonPluginsData(nxJson, packageJsonDeps);
+    const newValue = {
+        version: '6.0',
+        nxVersion: versions_1.nxVersion,
+        // compilerOptions may not exist, especially for package-based repos
+        pathMappings: tsConfig?.compilerOptions?.paths || {},
+        nxJsonPlugins,
+        pluginsConfig: nxJson?.pluginsConfig,
+        fileMap,
+        externalNodesHash,
+    };
+    return newValue;
+}
+/**
+ * Tracks the mtime of the project graph cache file after the last successful
+ * writeCache() call. Used by writeCacheIfStale() to skip redundant writes
+ * when no external process has modified the cache file since the last write.
+ */
+let lastWrittenCacheMtimeMs;
+function writeCache(cache, projectGraph, sourceMaps, errors) {
+    perf_hooks_1.performance.mark('write cache:start');
+    let retry = 1;
+    let done = false;
+    do {
+        // write first to a unique temporary filename and then do a
+        // rename of the file to the correct filename
+        // this is to avoid any problems with half-written files
+        // in case of crash and/or partially written files due
+        // to multiple parallel processes reading and writing this file
+        const unique = (Math.random().toString(16) + '0000000').slice(2, 10);
+        const tmpProjectGraphPath = `${exports.nxProjectGraph}~${unique}`;
+        const tmpFileMapPath = `${exports.nxFileMap}~${unique}`;
+        const tmpSourceMapPath = `${exports.nxSourceMaps}~${unique}`;
+        try {
+            (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, {
+                ...projectGraph,
+                errors,
+                computedAt: Date.now(),
+            });
+            (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
+            (0, fileutils_1.writeJsonFile)(tmpSourceMapPath, sourceMaps);
+            (0, node_fs_1.renameSync)(tmpSourceMapPath, exports.nxSourceMaps);
+            // only write the file map if there are no errors
+            // if there were errors, the errors make the filemap invalid
+            // TODO: We should be able to keep the valid part of the filemap if the errors being thrown told us which parts of the filemap were invalid
+            if (errors.length === 0) {
+                (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
+                (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            }
+            if ((0, is_on_daemon_1.isOnDaemon)()) {
+                logger_1.serverLogger.log(`Wrote project graph cache to ${exports.nxProjectGraph}${errors.length > 0 ? ' with errors' : ''}`);
+            }
+            try {
+                lastWrittenCacheMtimeMs = (0, node_fs_1.statSync)(exports.nxProjectGraph).mtimeMs;
+            }
+            catch {
+                lastWrittenCacheMtimeMs = undefined;
+            }
+            done = true;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                console.log(`ERROR (${retry}) when writing \n${err.message}\n${err.stack}`);
+            }
+            else {
+                console.log(`ERROR  (${retry}) unknown error when writing ${exports.nxProjectGraph} and ${exports.nxFileMap}`);
+            }
+            ++retry;
+        }
+    } while (!done && retry < 5);
+    if (!done) {
+        throw new Error(`Failed to write project graph cache to ${exports.nxProjectGraph} and ${exports.nxFileMap} after 5 attempts.`);
+    }
+    perf_hooks_1.performance.mark('write cache:end');
+    perf_hooks_1.performance.measure('write cache', 'write cache:start', 'write cache:end');
+}
+/**
+ * Writes the cache only if the on-disk cache file has been modified since
+ * this process last wrote it (i.e. an external process overwrote it), or
+ * if this process has never written the cache.
+ *
+ * Use this instead of writeCache() on hot paths where the same graph may
+ * be served multiple times without changing (e.g. the daemon responding
+ * to repeated client requests).
+ */
+function writeCacheIfStale(cache, projectGraph, sourceMaps, errors) {
+    if (lastWrittenCacheMtimeMs !== undefined) {
+        try {
+            const currentMtimeMs = (0, node_fs_1.statSync)(exports.nxProjectGraph).mtimeMs;
+            if (currentMtimeMs === lastWrittenCacheMtimeMs) {
+                return;
+            }
+        }
+        catch {
+            // File doesn't exist or can't be stat'd — proceed with write
+        }
+    }
+    writeCache(cache, projectGraph, sourceMaps, errors);
+}
+function shouldRecomputeWholeGraph(cache, packageJsonDeps, projects, nxJson, tsConfig, externalNodesHash) {
+    if (cache.version !== '6.0') {
+        return true;
+    }
+    if (cache.nxVersion !== versions_1.nxVersion) {
+        return true;
+    }
+    // we have a cached project that is no longer present
+    const cachedNodes = Object.keys(cache.fileMap.projectFileMap);
+    if (cachedNodes.some((p) => projects[p] === undefined)) {
+        return true;
+    }
+    // a path mapping for an existing project has changed
+    if (Object.keys(cache.pathMappings).some((t) => {
+        const cached = cache.pathMappings && cache.pathMappings[t]
+            ? JSON.stringify(cache.pathMappings[t])
+            : undefined;
+        const notCached = tsConfig?.compilerOptions?.paths && tsConfig?.compilerOptions?.paths[t]
+            ? JSON.stringify(tsConfig.compilerOptions.paths[t])
+            : undefined;
+        return cached !== notCached;
+    })) {
+        return true;
+    }
+    // a new plugin has been added
+    if (JSON.stringify(getNxJsonPluginsData(nxJson, packageJsonDeps)) !==
+        JSON.stringify(cache.nxJsonPlugins)) {
+        return true;
+    }
+    if (JSON.stringify(nxJson?.pluginsConfig) !==
+        JSON.stringify(cache.pluginsConfig)) {
+        return true;
+    }
+    // Check if external nodes have changed
+    if (externalNodesHash !== cache.externalNodesHash) {
+        return true;
+    }
+    return false;
+}
+/*
+This can only be invoked when the list of projects is either the same
+or new projects have been added, so every project in the cache has a corresponding
+project in fileMap
+*/
+function extractCachedFileData(fileMap, c) {
+    const filesToProcess = {
+        nonProjectFiles: [],
+        projectFileMap: {},
+    };
+    const cachedFileData = {
+        nonProjectFiles: {},
+        projectFileMap: {},
+    };
+    const currentProjects = Object.keys(fileMap.projectFileMap).filter((name) => fileMap.projectFileMap[name].length > 0);
+    currentProjects.forEach((p) => {
+        processProjectNode(p, c.fileMap.projectFileMap, cachedFileData.projectFileMap, filesToProcess.projectFileMap, fileMap);
+    });
+    processNonProjectFiles(c.fileMap.nonProjectFiles, fileMap.nonProjectFiles, filesToProcess.nonProjectFiles, cachedFileData.nonProjectFiles);
+    return {
+        filesToProcess,
+        cachedFileData,
+    };
+}
+function processNonProjectFiles(cachedFiles, nonProjectFiles, filesToProcess, cachedFileData) {
+    const cachedHashMap = new Map(cachedFiles.map((f) => [f.file, f]));
+    for (const f of nonProjectFiles) {
+        const cachedFile = cachedHashMap.get(f.file);
+        if (!cachedFile || cachedFile.hash !== f.hash) {
+            filesToProcess.push(f);
+        }
+        else {
+            cachedFileData[f.file] = cachedFile;
+        }
+    }
+}
+function processProjectNode(projectName, cachedFileMap, cachedFileData, filesToProcess, { projectFileMap }) {
+    if (!cachedFileMap[projectName]) {
+        filesToProcess[projectName] = projectFileMap[projectName];
+        return;
+    }
+    const fileDataFromCache = {};
+    for (let f of cachedFileMap[projectName]) {
+        fileDataFromCache[f.file] = f;
+    }
+    if (!cachedFileData[projectName]) {
+        cachedFileData[projectName] = {};
+    }
+    for (let f of projectFileMap[projectName]) {
+        const fromCache = fileDataFromCache[f.file];
+        if (fromCache && fromCache.hash == f.hash) {
+            cachedFileData[projectName][f.file] = fromCache;
+        }
+        else {
+            if (!filesToProcess[projectName]) {
+                filesToProcess[projectName] = [];
+            }
+            filesToProcess[projectName].push(f);
+        }
+    }
+}
+function getNxJsonPluginsData(nxJson, packageJsonDeps) {
+    return (nxJson?.plugins || []).map((p) => {
+        const [plugin, options] = typeof p === 'string' ? [p] : [p.plugin, p.options];
+        return {
+            name: plugin,
+            version: packageJsonDeps[plugin],
+            options,
+        };
+    });
+}

package/src/project-graph/operators.d.ts

@@ -0,0 +1,13 @@
+import { ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode } from '../config/project-graph';
+/**
+ * Returns a new project graph where all the edges are reversed.
+ *
+ * For instance, if project A depends on B, in the reversed graph
+ * B will depend on A.
+ */
+export declare function reverse(graph: ProjectGraph): ProjectGraph;
+export declare function filterNodes(predicate?: (n: ProjectGraphProjectNode) => boolean): (p: ProjectGraph) => ProjectGraph;
+export declare function isNpmProject(project: ProjectGraphProjectNode | ProjectGraphExternalNode): project is ProjectGraphExternalNode;
+export declare const pruneExternalNodes: (p: ProjectGraph) => ProjectGraph;
+export declare function withDeps(original: ProjectGraph, subsetNodes: ProjectGraphProjectNode[]): ProjectGraph;
+//# sourceMappingURL=operators.d.ts.map

package/src/project-graph/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/project-graph/operators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AAIjC;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAkCzD;AAED,wBAAgB,WAAW,CACzB,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,uBAAuB,KAAK,OAAO,GAClD,CAAC,CAAC,EAAE,YAAY,KAAK,YAAY,CAoBnC;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,uBAAuB,GAAG,wBAAwB,GAC1D,OAAO,IAAI,wBAAwB,CAErC;AAED,eAAO,MAAM,kBAAkB,MA5BxB,YAAY,KAAK,YA4BuB,CAAC;AAEhD,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,YAAY,EACtB,WAAW,EAAE,uBAAuB,EAAE,GACrC,YAAY,CA8Cd"}

package/src/project-graph/operators.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneExternalNodes = void 0;
+exports.reverse = reverse;
+exports.filterNodes = filterNodes;
+exports.isNpmProject = isNpmProject;
+exports.withDeps = withDeps;
+const reverseMemo = new Map();
+/**
+ * Returns a new project graph where all the edges are reversed.
+ *
+ * For instance, if project A depends on B, in the reversed graph
+ * B will depend on A.
+ */
+function reverse(graph) {
+    const resultFromMemo = reverseMemo.get(graph);
+    if (resultFromMemo) {
+        return resultFromMemo;
+    }
+    const result = {
+        ...graph,
+        nodes: { ...graph.nodes },
+        externalNodes: { ...graph.externalNodes },
+        dependencies: {},
+    };
+    Object.keys(graph.nodes).forEach((n) => (result.dependencies[n] = []));
+    // we need to keep external node's reverse dependencies to trace our route back
+    if (graph.externalNodes) {
+        Object.keys(graph.externalNodes).forEach((n) => (result.dependencies[n] = []));
+    }
+    Object.values(graph.dependencies).forEach((byProject) => {
+        byProject.forEach((dep) => {
+            const dependency = result.dependencies[dep.target];
+            if (dependency) {
+                dependency.push({
+                    type: dep.type,
+                    source: dep.target,
+                    target: dep.source,
+                });
+            }
+        });
+    });
+    reverseMemo.set(graph, result);
+    reverseMemo.set(result, graph);
+    return result;
+}
+function filterNodes(predicate) {
+    return (original) => {
+        const graph = { nodes: {}, dependencies: {} };
+        const added = new Set();
+        Object.values(original.nodes).forEach((n) => {
+            if (!predicate || predicate(n)) {
+                graph.nodes[n.name] = n;
+                graph.dependencies[n.name] = [];
+                added.add(n.name);
+            }
+        });
+        Object.values(original.dependencies).forEach((ds) => {
+            ds.forEach((d) => {
+                if (added.has(d.source) && added.has(d.target)) {
+                    graph.dependencies[d.source].push(d);
+                }
+            });
+        });
+        return graph;
+    };
+}
+function isNpmProject(project) {
+    return project?.type === 'npm';
+}
+exports.pruneExternalNodes = filterNodes();
+function withDeps(original, subsetNodes) {
+    const res = { nodes: {}, dependencies: {} };
+    const visitedNodes = [];
+    const visitedEdges = [];
+    Object.values(subsetNodes).forEach(recurNodes);
+    Object.values(subsetNodes).forEach(recurEdges);
+    return res;
+    // ---------------------------------------------------------------------------
+    function recurNodes(node) {
+        if (visitedNodes.indexOf(node.name) > -1)
+            return;
+        res.nodes[node.name] = node;
+        if (!res.dependencies[node.name]) {
+            res.dependencies[node.name] = [];
+        }
+        visitedNodes.push(node.name);
+        original.dependencies[node.name].forEach((n) => {
+            if (original.nodes[n.target]) {
+                recurNodes(original.nodes[n.target]);
+            }
+        });
+    }
+    function recurEdges(node) {
+        if (visitedEdges.indexOf(node.name) > -1)
+            return;
+        visitedEdges.push(node.name);
+        const ds = original.dependencies[node.name];
+        ds.forEach((n) => {
+            if (!original.nodes[n.target]) {
+                return;
+            }
+            if (!res.dependencies[n.source]) {
+                res.dependencies[n.source] = [];
+            }
+            res.dependencies[n.source].push(n);
+        });
+        ds.forEach((n) => {
+            if (original.nodes[n.target]) {
+                recurEdges(original.nodes[n.target]);
+            }
+        });
+    }
+}

package/src/project-graph/plugins/get-plugins.d.ts

@@ -0,0 +1,5 @@
+import type { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function getPlugins(root?: string): Promise<LoadedNxPlugin[]>;
+export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPlugin[]>;
+export declare function cleanupPlugins(): void;
+//# sourceMappingURL=get-plugins.d.ts.map

package/src/project-graph/plugins/get-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-plugins.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/plugins/get-plugins.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAuBzD,wBAAsB,UAAU,CAC9B,IAAI,SAAgB,GACnB,OAAO,CAAC,cAAc,EAAE,CAAC,CA6C3B;AAaD,wBAAsB,qBAAqB,CAAC,IAAI,SAAgB,6BAyB/D;AAED,wBAAgB,cAAc,SAK7B"}