@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/requests/AssetGraphRequestRust.js

@@ -0,0 +1,471 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssetGraphRequestRust = createAssetGraphRequestRust;
+exports.getAssetGraph = getAssetGraph;
+const assert_1 = __importDefault(require("assert"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const logger_1 = __importStar(require("@atlaspack/logger"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const AssetGraph_1 = __importDefault(require("../AssetGraph"));
+const ReporterRunner_1 = require("../ReporterRunner");
+const RequestTracker_1 = require("../RequestTracker");
+const SymbolPropagation_1 = require("../SymbolPropagation");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const Environment_1 = require("../Environment");
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+const assert_2 = __importDefault(require("assert"));
+function createAssetGraphRequestRust(rustAtlaspack) {
+    return (input) => ({
+        type: RequestTracker_1.requestTypes.asset_graph_request,
+        id: input.name,
+        run: async (runInput) => {
+            let options = runInput.options;
+            let { assetGraphPromise, commitPromise } = await rustAtlaspack.buildAssetGraph((eventJson) => {
+                let event = JSON.parse(eventJson);
+                (0, ReporterRunner_1.report)(event);
+            });
+            let [serializedAssetGraph, assetGraphError] = (await assetGraphPromise);
+            if (assetGraphError) {
+                throw new diagnostic_1.default({
+                    diagnostic: assetGraphError,
+                });
+            }
+            // Don't reuse a previous asset graph result if Rust didn't have one too
+            let prevResult = null;
+            if (serializedAssetGraph.hadPreviousGraph) {
+                prevResult =
+                    await runInput.api.getPreviousResult();
+            }
+            let { assetGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph, prevResult?.assetGraph));
+            let changedAssetsPropagation = new Set(changedAssets.keys());
+            let result = {
+                assetGraph,
+                assetRequests: [],
+                assetGroupsWithRemovedParents: new Set(),
+                changedAssets,
+                changedAssetsPropagation,
+                previousSymbolPropagationErrors: undefined,
+            };
+            // When v3AssetGraphSyncImprovements is enabled, wrap downstream steps
+            // in try/catch and store the result even on error. This prevents Rust/JS
+            // divergence when symbol propagation or commit_assets fails.
+            let storeResultOnError = (0, feature_flags_1.getFeatureFlag)('v3AssetGraphSyncImprovements');
+            try {
+                // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+                if (input.skipSymbolProp) {
+                    logger_1.default.verbose({
+                        origin: '@atlaspack/core',
+                        message: 'Skipping symbol propagation for runtime asset graph',
+                    });
+                }
+                else {
+                    let errors = (0, SymbolPropagation_1.propagateSymbols)({
+                        options,
+                        assetGraph,
+                        changedAssetsPropagation,
+                        assetGroupsWithRemovedParents: new Set(),
+                        previousErrors: new Map(), //this.previousSymbolPropagationErrors,
+                    });
+                    if (errors.size > 0) {
+                        // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+                        // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+                        throw new diagnostic_1.default({
+                            diagnostic: [...errors.values()][0],
+                        });
+                    }
+                }
+                await (0, dumpGraphToGraphViz_1.default)(assetGraph, 'AssetGraphV3');
+                let [_commitResult, commitError] = await commitPromise;
+                if (commitError) {
+                    throw new diagnostic_1.default({
+                        diagnostic: {
+                            message: 'Error committing asset graph in Rust: ' + commitError.message,
+                        },
+                    });
+                }
+                await runInput.api.storeResult(result);
+                runInput.api.invalidateOnBuild();
+            }
+            catch (e) {
+                if (storeResultOnError) {
+                    // Store the graph even on error to prevent Rust/JS divergence.
+                    // The graph from getAssetGraph is structurally correct — only
+                    // downstream processing (symbols, commit) failed.
+                    await runInput.api.storeResult(result);
+                    runInput.api.invalidateOnBuild();
+                }
+                throw e;
+            }
+            return result;
+        },
+        input,
+    });
+}
+function getAssetGraph(serializedGraph, prevAssetGraph) {
+    let graph;
+    let reuseEdges = false;
+    let clonePrevGraph = (0, feature_flags_1.getFeatureFlag)('v3AssetGraphSyncImprovements');
+    if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+        if (clonePrevGraph) {
+            graph = new AssetGraph_1.default({
+                _contentKeyToNodeId: new Map(prevAssetGraph._contentKeyToNodeId),
+                _nodeIdToContentKey: new Map(prevAssetGraph._nodeIdToContentKey),
+                nodes: [...prevAssetGraph.nodes],
+                rootNodeId: prevAssetGraph.rootNodeId,
+                adjacencyList: prevAssetGraph.adjacencyList,
+            });
+        }
+        else {
+            graph = new AssetGraph_1.default({
+                _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+                _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+                nodes: prevAssetGraph.nodes,
+                rootNodeId: prevAssetGraph.rootNodeId,
+                adjacencyList: prevAssetGraph.adjacencyList,
+            });
+        }
+        reuseEdges = true;
+    }
+    else if (prevAssetGraph &&
+        (serializedGraph.updates.length > 0 || serializedGraph.nodes.length > 0)) {
+        if (clonePrevGraph) {
+            graph = new AssetGraph_1.default({
+                _contentKeyToNodeId: new Map(prevAssetGraph._contentKeyToNodeId),
+                _nodeIdToContentKey: new Map(prevAssetGraph._nodeIdToContentKey),
+                nodes: [...prevAssetGraph.nodes],
+                initialCapacity: serializedGraph.edges.length,
+                // Accomodate the root node
+                initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+                rootNodeId: prevAssetGraph.rootNodeId,
+            });
+        }
+        else {
+            graph = new AssetGraph_1.default({
+                _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+                _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+                nodes: prevAssetGraph.nodes,
+                initialCapacity: serializedGraph.edges.length,
+                // Accomodate the root node
+                initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+                rootNodeId: prevAssetGraph.rootNodeId,
+            });
+        }
+        graph.safeToIncrementallyBundle = false;
+    }
+    else {
+        graph = new AssetGraph_1.default({
+            _contentKeyToNodeId: new Map(),
+            _nodeIdToContentKey: new Map(),
+            initialCapacity: serializedGraph.edges.length,
+            // Accomodate the root node
+            initialNodeCapacity: serializedGraph.nodes.length + 1,
+        });
+        let rootNodeId = graph.addNodeByContentKey('@@root', {
+            id: '@@root',
+            type: 'root',
+            value: null,
+        });
+        graph.setRootNodeId(rootNodeId);
+        graph.safeToIncrementallyBundle = false;
+    }
+    (0, assert_1.default)(graph, 'Asset graph not initialized');
+    (0, assert_1.default)(graph.rootNodeId != null, 'Asset graph has no root node');
+    // @ts-expect-error TS7031
+    function mapSymbols({ exported, ...symbol }) {
+        let jsSymbol = {
+            local: symbol.local ?? undefined,
+            loc: symbol.loc ?? undefined,
+            isWeak: symbol.isWeak,
+            meta: {
+                isEsm: symbol.isEsmExport,
+                isStaticBindingSafe: symbol.isStaticBindingSafe,
+            },
+        };
+        if (symbol.exported) {
+            // @ts-expect-error TS2339
+            jsSymbol.exported = symbol.exported;
+        }
+        return [exported, jsSymbol];
+    }
+    // See crates/atlaspack_core/src/types/environment.rs
+    let changedAssets = new Map();
+    let entry = 0;
+    let envs = new Map();
+    let getEnvId = (env) => {
+        let envKey = [
+            env.context,
+            env.engines.atlaspack,
+            env.engines.browsers,
+            env.engines.electron,
+            env.engines.node,
+            env.includeNodeModules,
+            env.isLibrary,
+            env.outputFormat,
+            env.shouldScopeHoist,
+            env.shouldOptimize,
+            env.sourceType,
+        ].join(':');
+        let envId = envs.get(envKey);
+        if (envId == null) {
+            envId = (0, Environment_1.getEnvironmentHash)(env);
+            envs.set(envKey, envId);
+        }
+        return envId;
+    };
+    function describeNode(node) {
+        const base = { type: node.type, id: node.id };
+        if (node.type === 'asset') {
+            return {
+                ...base,
+                filePath: node.value.filePath,
+                fileType: node.value.type,
+                pipeline: node.value.pipeline,
+            };
+        }
+        else if (node.type === 'dependency') {
+            return {
+                ...base,
+                specifier: node.value.specifier,
+                specifierType: node.value.specifierType,
+                sourceAssetId: node.value.sourceAssetId,
+                sourcePath: node.value.sourcePath,
+            };
+        }
+        return base;
+    }
+    function buildDivergenceDiagnostics(divergenceType, newNode, existingNode, index) {
+        return {
+            contentKey: newNode.id,
+            divergenceType,
+            newNode: describeNode(newNode),
+            existingNode: existingNode ? describeNode(existingNode) : null,
+            iterationIndex: index,
+            totalSerializedNodes: nodesCount,
+            newNodesCount: serializedGraph.nodes.length,
+            updatesCount: serializedGraph.updates.length,
+            edgesCount: serializedGraph.edges.length,
+            hadPreviousGraph: !!prevAssetGraph,
+            safeToSkipBundling: serializedGraph.safeToSkipBundling,
+            graphNodeCount: graph._contentKeyToNodeId.size,
+        };
+    }
+    function updateNode(newNode, isUpdateNode, index) {
+        let healDivergence = (0, feature_flags_1.getFeatureFlag)('v3AssetGraphSyncImprovements');
+        if (isUpdateNode) {
+            let existingNode = graph.getNodeByContentKey(newNode.id);
+            if (healDivergence) {
+                if (existingNode) {
+                    (0, assert_2.default)(existingNode.type === newNode.type);
+                    Object.assign(existingNode, newNode);
+                }
+                else {
+                    // Rust sent an update for a node JS doesn't have.
+                    // This means JS's graph is stale. Add the node as new instead.
+                    // This handles the "undefined == true" error class.
+                    let diagnostics = buildDivergenceDiagnostics('update_node_not_found', newNode, existingNode, index);
+                    logger_1.default.warn({
+                        origin: '@atlaspack/core',
+                        message: `Rust/JS asset graph divergence healed: update node not found, ` +
+                            `adding as new. contentKey=${newNode.id} type=${newNode.type} iterationIndex=${index}`,
+                        meta: {
+                            trackableEvent: 'asset_graph_divergence_healed',
+                            ...diagnostics,
+                        },
+                    });
+                    graph.addNodeByContentKey(newNode.id, newNode);
+                }
+            }
+            else {
+                (0, assert_2.default)(existingNode && existingNode.type === newNode.type);
+                Object.assign(existingNode, newNode);
+            }
+        }
+        else {
+            if (healDivergence) {
+                if (graph.hasContentKey(newNode.id)) {
+                    // Rust sent a "new" node that JS already has.
+                    // This means JS's graph has nodes that Rust considers new.
+                    // Treat as an update instead of throwing.
+                    // This handles the "Graph already has content key" error class.
+                    let existingNode = graph.getNodeByContentKey(newNode.id);
+                    let diagnostics = buildDivergenceDiagnostics('new_node_already_exists', newNode, existingNode, index);
+                    logger_1.default.warn({
+                        origin: '@atlaspack/core',
+                        message: `Rust/JS asset graph divergence healed: new node already exists, ` +
+                            `treating as update. contentKey=${newNode.id} type=${newNode.type} iterationIndex=${index}`,
+                        meta: {
+                            trackableEvent: 'asset_graph_divergence_healed',
+                            ...diagnostics,
+                        },
+                    });
+                    if (existingNode) {
+                        Object.assign(existingNode, newNode);
+                    }
+                }
+                else {
+                    graph.addNodeByContentKey(newNode.id, newNode);
+                }
+            }
+            else {
+                try {
+                    graph.addNodeByContentKey(newNode.id, newNode);
+                }
+                catch (e) {
+                    if (e instanceof Error &&
+                        e.message.includes('already has content key')) {
+                        let existingNode = graph.getNodeByContentKey(newNode.id);
+                        let diagnostics = buildDivergenceDiagnostics('new_node_already_exists', newNode, existingNode, index);
+                        throw new Error(`Graph already has content key '${newNode.id}'. Diagnostics: ${JSON.stringify(diagnostics, null, 2)}`);
+                    }
+                    throw e;
+                }
+            }
+        }
+    }
+    let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
+    let nodesCount = serializedGraph.nodes.length + serializedGraph.updates.length;
+    for (let index = 0; index < nodesCount; index++) {
+        let isUpdateNode = index >= nodeTypeSwitchoverIndex;
+        let node = isUpdateNode
+            ? serializedGraph.updates[index - nodeTypeSwitchoverIndex]
+            : serializedGraph.nodes[index];
+        node = JSON.parse(node);
+        if (node.type === 'entry') {
+            let id = 'entry:' + ++entry;
+            graph.addNodeByContentKey(id, {
+                id: id,
+                type: 'root',
+                value: null,
+            });
+        }
+        else if (node.type === 'asset') {
+            let asset = node.value;
+            let id = asset.id;
+            asset.committed = true;
+            asset.contentKey = id;
+            asset.env.id = (0, feature_flags_1.getFeatureFlag)('environmentDeduplication')
+                ? // TODO: Rust can do this and avoid copying a significant amount of data over
+                    (0, Environment_1.getEnvironmentHash)(asset.env)
+                : getEnvId(asset.env);
+            asset.mapKey = `map:${asset.id}`;
+            asset.env = (0, EnvironmentManager_1.toEnvironmentRef)(asset.env);
+            // This is populated later when we map the edges between assets and dependencies
+            asset.dependencies = new Map();
+            // We need to add this property for source map handling, as some assets like runtimes
+            // are processed after the Rust transformation and take the v2 code path
+            asset.meta.isV3 = true;
+            if (asset.symbols != null) {
+                asset.symbols = new Map(asset.symbols.map(mapSymbols));
+            }
+            changedAssets.set(id, asset);
+            let assetNode = {
+                id,
+                type: 'asset',
+                usedSymbols: new Set(),
+                usedSymbolsDownDirty: true,
+                usedSymbolsUpDirty: true,
+                value: asset,
+            };
+            updateNode(assetNode, isUpdateNode, index);
+        }
+        else if (node.type === 'dependency') {
+            let { dependency, id } = node.value;
+            dependency.id = id;
+            dependency.env.id = (0, feature_flags_1.getFeatureFlag)('environmentDeduplication')
+                ? // TODO: Rust can do this and avoid copying a significant amount of data over
+                    (0, Environment_1.getEnvironmentHash)(dependency.env)
+                : getEnvId(dependency.env);
+            dependency.env = (0, EnvironmentManager_1.toEnvironmentRef)(dependency.env);
+            if (dependency.symbols != null) {
+                dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));
+            }
+            let usedSymbolsDown = new Set();
+            let usedSymbolsUp = new Map();
+            if (node.used_symbols_up) {
+                for (let usedSymbol of node.used_symbols_up) {
+                    // Transform Rust UsedSymbol { symbol: Symbol, asset: string, resolved_symbol: string }
+                    // to JS format { symbol: string, asset: string } where symbol is the resolved name
+                    const exportedName = usedSymbol.symbol.exported;
+                    usedSymbolsUp.set(exportedName, {
+                        asset: usedSymbol.asset,
+                        symbol: usedSymbol.resolved_symbol ?? exportedName,
+                    });
+                }
+            }
+            if (dependency.isEntry && dependency.isLibrary) {
+                usedSymbolsDown.add('*');
+                usedSymbolsUp.set('*', undefined);
+            }
+            let depNode = {
+                id,
+                type: 'dependency',
+                deferred: false,
+                excluded: false,
+                hasDeferred: node.has_deferred,
+                // @ts-expect-error TS2322
+                usedSymbolsDown,
+                usedSymbolsDownDirty: true,
+                usedSymbolsUp,
+                usedSymbolsUpDirtyDown: true,
+                usedSymbolsUpDirtyUp: true,
+                value: dependency,
+            };
+            updateNode(depNode, isUpdateNode, index);
+        }
+    }
+    if (!reuseEdges) {
+        for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+            let from = serializedGraph.edges[i];
+            let to = serializedGraph.edges[i + 1];
+            let fromNode = graph.getNode(from);
+            let toNode = graph.getNode(to);
+            if (fromNode?.type === 'dependency') {
+                (0, assert_1.default)(toNode?.type === 'asset');
+            }
+            if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+                fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+            }
+            graph.addEdge(from, to);
+        }
+    }
+    return {
+        assetGraph: graph,
+        changedAssets,
+    };
+}

package/dist/requests/AssetRequest.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createAssetRequest;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const rust_1 = require("@atlaspack/rust");
+const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
+const DevDepRequest_1 = require("./DevDepRequest");
+const ConfigRequest_1 = require("./ConfigRequest");
+const projectPath_1 = require("../projectPath");
+const ReporterRunner_1 = require("../ReporterRunner");
+const RequestTracker_1 = require("../RequestTracker");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+function createAssetRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.asset_request,
+        id: getId(input),
+        run,
+        input,
+    };
+}
+const type = 'asset_request';
+function getId(input) {
+    return (0, rust_1.hashString)(type +
+        (0, projectPath_1.fromProjectPathRelative)(input.filePath) +
+        (0, EnvironmentManager_1.toEnvironmentId)(input.env) +
+        String(input.isSource) +
+        String(input.sideEffects) +
+        (input.code ?? '') +
+        ':' +
+        (input.pipeline ?? '') +
+        ':' +
+        (input.query ?? ''));
+}
+// @ts-expect-error TS7031
+async function run({ input, api, farm, invalidateReason, options }) {
+    (0, ReporterRunner_1.report)({
+        type: 'buildProgress',
+        phase: 'transforming',
+        filePath: (0, projectPath_1.fromProjectPath)(options.projectRoot, input.filePath),
+    });
+    api.invalidateOnFileUpdate(input.filePath);
+    let start = Date.now();
+    let { optionsRef, ...rest } = input;
+    let { cachePath } = (0, nullthrows_1.default)(
+    // @ts-expect-error TS2347
+    await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let previousDevDepRequests = new Map(await Promise.all(api
+        .getSubRequests()
+        // @ts-expect-error TS7006
+        .filter((req) => req.requestType === RequestTracker_1.requestTypes.dev_dep_request)
+        // @ts-expect-error TS7006
+        .map(async (req) => [
+        req.id,
+        // @ts-expect-error TS2347
+        (0, nullthrows_1.default)(await api.getRequestResult(req.id)),
+    ])));
+    let request = {
+        ...rest,
+        invalidateReason,
+        devDeps: new Map([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => api.canSkipSubrequest(id))
+            .map(([, req]) => [
+            `${req.specifier}:${(0, projectPath_1.fromProjectPathRelative)(req.resolveFrom)}`,
+            req.hash,
+        ])),
+        invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => !api.canSkipSubrequest(id))
+            .flatMap(([, req]) => {
+            return [
+                {
+                    specifier: req.specifier,
+                    resolveFrom: req.resolveFrom,
+                },
+                // @ts-expect-error TS7006
+                ...(req.additionalInvalidations ?? []).map((i) => ({
+                    specifier: i.specifier,
+                    resolveFrom: i.resolveFrom,
+                })),
+            ];
+        })),
+    };
+    let { assets, configRequests, error, invalidations, devDepRequests } = (await farm.createHandle('runTransform', input.isSingleChangeRebuild)({
+        configCachePath: cachePath,
+        optionsRef,
+        request,
+    }));
+    let time = Date.now() - start;
+    if (assets) {
+        for (let asset of assets) {
+            asset.stats.time = time;
+        }
+    }
+    for (let filePath of invalidations.invalidateOnFileChange) {
+        api.invalidateOnFileUpdate(filePath);
+        api.invalidateOnFileDelete(filePath);
+    }
+    for (let invalidation of invalidations.invalidateOnFileCreate) {
+        api.invalidateOnFileCreate(invalidation);
+    }
+    for (let env of invalidations.invalidateOnEnvChange) {
+        api.invalidateOnEnvChange(env);
+    }
+    for (let option of invalidations.invalidateOnOptionChange) {
+        api.invalidateOnOptionChange(option);
+    }
+    if (invalidations.invalidateOnStartup) {
+        api.invalidateOnStartup();
+    }
+    if (invalidations.invalidateOnBuild) {
+        api.invalidateOnBuild();
+    }
+    for (let devDepRequest of devDepRequests) {
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+    for (let configRequest of configRequests) {
+        await (0, ConfigRequest_1.runConfigRequest)(api, configRequest);
+    }
+    if (error != null) {
+        throw new diagnostic_1.default({ diagnostic: error });
+    }
+    else {
+        return (0, nullthrows_1.default)(assets);
+    }
+}