@depup/nx 22.5.4-depup.0

package/src/command-line/release/version/version-actions.d.ts

@@ -0,0 +1,200 @@
+import { ReleaseType } from 'semver';
+import { NxReleaseVersionConfiguration } from '../../../config/nx-json';
+import type { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode } from '../../../config/project-graph';
+import type { Tree } from '../../../generators/tree';
+import type { ReleaseGroupWithName } from '../config/filter-release-groups';
+import type { FinalConfigForProject } from '../utils/release-graph';
+export type SemverBumpType = ReleaseType | 'none';
+/**
+ * Implementation details of performing any actions after all projects have been versioned.
+ * An example might be updating a workspace level lock file.
+ *
+ * NOTE: By the time this function is invoked, the tree will have been flushed back to disk,
+ * so it is not accessible here.
+ *
+ * The function should return lists of changed and deleted files so that they can be staged
+ * and committed if appropriate.
+ *
+ * NOTE: The versionActionsOptions passed here are the ones at the root of release.version config,
+ * different values per release group or project will not be respected here because this takes
+ * place after all projects have been versioned.
+ */
+export type AfterAllProjectsVersioned = (cwd: string, opts: {
+    dryRun?: boolean;
+    verbose?: boolean;
+    rootVersionActionsOptions?: Record<string, unknown>;
+}) => Promise<{
+    changedFiles: string[];
+    deletedFiles: string[];
+}>;
+export declare function resolveVersionActionsForProject(tree: Tree, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, finalConfigForProject: FinalConfigForProject): Promise<{
+    versionActionsPath: string;
+    versionActions: VersionActions;
+    afterAllProjectsVersioned: AfterAllProjectsVersioned;
+}>;
+export declare abstract class VersionActions {
+    releaseGroup: ReleaseGroupWithName;
+    projectGraphNode: ProjectGraphProjectNode;
+    finalConfigForProject: FinalConfigForProject;
+    /**
+     * The available valid filenames of the manifest file relevant to the current versioning use-case.
+     *
+     * E.g. for JavaScript projects this would be ["package.json"], but for Gradle it would be
+     * ["build.gradle", "build.gradle.kts"].
+     *
+     * If a manifest file is not applicable to the current versioning use-case, this should be set to null.
+     */
+    abstract validManifestFilenames: string[] | null;
+    /**
+     * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
+     * versions and dependencies are determined. If no manifest files should be updated based on the user's
+     * configuration, this will be an empty array.
+     *
+     * The final value for preserveLocalDependencyProtocols will be based on the resolved config for the current
+     * project and any overrides from the user's configuration for the manifestRootsToUpdate.
+     */
+    manifestsToUpdate: {
+        manifestPath: string;
+        preserveLocalDependencyProtocols: boolean;
+    }[];
+    constructor(releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, finalConfigForProject: FinalConfigForProject);
+    /**
+     * Asynchronous initialization of the version actions and resolution of manifest paths.
+     * Note: This does NOT validate that manifest files exist - that happens later in validate().
+     */
+    init(tree: Tree): Promise<void>;
+    /**
+     * Validates that manifest files actually exist.
+     * This will be called after all preVersionCommands have run.
+     */
+    validate(tree: Tree): Promise<void>;
+    /**
+     * The default implementation will calculate the new version based on semver. If semver is not applicable to a
+     * particular versioning use-case, this method should be overridden with custom logic.
+     *
+     * @param {string | null} currentVersion - The current version of the project, or null if the current version resolver is set to 'none'
+     * @param {string} newVersionInput - The new version input provided by the user, such as a semver relative bump type, or an explicit version
+     * @param {string} newVersionInputReason - The reason for the new version input used to inform the log message to show to the user
+     * @param {Record<string, unknown>} newVersionInputReasonData - The data to interpolate into the new version input reason
+     * @param {string} preid - The preid to use for the new version, if applicable
+     */
+    calculateNewVersion(currentVersion: string | null, newVersionInput: string, newVersionInputReason: string, newVersionInputReasonData: Record<string, unknown>, preid: string): Promise<{
+        newVersion: string;
+        logText: string;
+    }>;
+    /**
+     * Implementation details of resolving a project's current version from a valid manifest file. It should
+     * return an object with the current version and the filename of the resolved manifest path so that the
+     * logs provided to the user are as specific as possible.
+     *
+     * This method will only be called if the user has configured their currentVersionResolver to be "disk".
+     *
+     * If the version actions implementation does not support a manifest file, this method can either throw
+     * an error or return null. In this case, nx release will handle showing the user a relevant error about
+     * their currentVersionResolver configuration being fundamentally incompatible with the current version
+     * actions implementation resolved for the project being versioned and they can change it to something else
+     * (e.g. "registry" or "git-tag").
+     *
+     * NOTE: The version actions implementation does not need to provide the method for handling resolution
+     * from git tags, this is done directly by nx release.
+     */
+    abstract readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
+        currentVersion: string;
+        manifestPath: string;
+    } | null>;
+    /**
+     * Implementation details of resolving a project's current version from a remote registry.
+     *
+     * The specific logText it returns will be combined with the generic remote registry log text and allows
+     * the implementation to provide more specific information to the user about what registry URL
+     * was used, what dist-tag etc.
+     *
+     * If the version actions implementation does not support resolving from a remote registry, this method
+     * can either throw an error or return null. In this case, nx release will handle showing the user a relevant
+     * error about their currentVersionResolver configuration being fundamentally incompatible with the current
+     * version actions implementation resolved for the project being versioned and they can change it to something
+     * else (e.g. "disk" or "git-tag").
+     *
+     * NOTE: The version actions implementation does not need to provide the method for handling resolution
+     * from git tags, this is done directly by nx release.
+     */
+    abstract readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionConfiguration['currentVersionResolverMetadata']): Promise<{
+        currentVersion: string | null;
+        logText: string;
+    } | null>;
+    /**
+     * Implementation details of resolving the dependencies of a project.
+     *
+     * The default implementation will read dependencies from the Nx project graph. In many cases this will be sufficient,
+     * because the project graph will have been constructed using plugins from relevant ecosystems that should have applied
+     * any and all relevant metadata to the project nodes and dependency edges.
+     *
+     * If, however, the project graph cannot be used as the source of truth for whatever reason, then this default method
+     * can simply be overridden in the final version actions implementation.
+     */
+    readDependencies(tree: Tree, projectGraph: ProjectGraph): Promise<ProjectGraphDependency[]>;
+    /**
+     * Implementation details of resolving the current version of a specific dependency of the project.
+     *
+     * The dependency collection is the type of dependency collection to which the dependency belongs, such as 'dependencies',
+     * 'devDependencies', 'peerDependencies', 'optionalDependencies', etc. This is ecosystem and use-case specific.
+     *
+     * The currentVersion and dependencyCollection fields will be used to populate the rawVersionSpec and dependencyCollection
+     * fields on the VersionData that gets returned from the programmatic API. `null` values are accepted for these if the current
+     * version or dependencyCollection is not applicable/resolvable at all, but they should be provided if possible.
+     *
+     * The currentVersion will also be used when calculating the final versionPrefix to apply for the new dependency
+     * version, based on the user's configuration, if applicable.
+     */
+    abstract readCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
+        currentVersion: string | null;
+        dependencyCollection: string | null;
+    }>;
+    /**
+     * Implementation details of updating a newly derived version in some source of truth.
+     *
+     * For libraries/packages, this will usually involve writing to one or more manifest files
+     * (e.g. potentially both src and dist), such as a package.json/Cargo.toml/etc, but for
+     * application deployments it might involve updating something else instead, it depends on
+     * the type of application.
+     *
+     * It should return an array of log messages that will be displayed unmodified to the user
+     * after the version has been updated.
+     */
+    abstract updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
+    /**
+     * Implementation details of updating dependencies in some source of truth.
+     *
+     * For libraries/packages, this will usually involve writing to one or more manifest files
+     * (e.g. potentially both src and dist), such as a package.json/Cargo.toml/etc,
+     * with new dependency versions, but for application deployments it might involve
+     * updating something else instead, it depends on the type of application.
+     *
+     * It should return an array of log messages that will be displayed unmodified to the user
+     * after the dependencies have been updated.
+     */
+    abstract updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+}
+export declare class NOOP_VERSION_ACTIONS extends VersionActions {
+    validManifestFilenames: any;
+    validate(tree: Tree): Promise<void>;
+    readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionConfiguration['currentVersionResolverMetadata']): Promise<{
+        currentVersion: string | null;
+        logText: string;
+    } | null>;
+    readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
+        currentVersion: string;
+        manifestPath: string;
+    } | null>;
+    readCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
+        currentVersion: string | null;
+        dependencyCollection: string | null;
+    }>;
+    calculateNewVersion(currentVersion: string | null, newVersionInput: string, newVersionInputReason: string, newVersionInputReasonData: Record<string, unknown>, preid: string): Promise<{
+        newVersion: string;
+        logText: string;
+    }>;
+    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+    updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
+}
+//# sourceMappingURL=version-actions.d.ts.map

package/src/command-line/release/version/version-actions.d.ts.map

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

package/src/command-line/release/version/version-actions.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOOP_VERSION_ACTIONS = exports.VersionActions = void 0;
+exports.resolveVersionActionsForProject = resolveVersionActionsForProject;
+const node_path_1 = require("node:path");
+const register_1 = require("../../../plugins/js/utils/register");
+const typescript_1 = require("../../../plugins/js/utils/typescript");
+const utils_1 = require("../../../tasks-runner/utils");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const config_1 = require("../config/config");
+const semver_1 = require("../utils/semver");
+const release_group_processor_1 = require("./release-group-processor");
+function resolveVersionActionsPath(path, projectGraphNode) {
+    try {
+        return require.resolve(path);
+    }
+    catch {
+        try {
+            return require.resolve((0, node_path_1.join)(workspace_root_1.workspaceRoot, path));
+        }
+        catch {
+            if (path === config_1.DEFAULT_VERSION_ACTIONS_PATH) {
+                throw new Error(`Unable to resolve the default "versionActions" implementation for project "${projectGraphNode.name}" at path: "${path}"
+
+- If this is a JavaScript/TypeScript project, it is likely that you simply need to install the "@nx/js" plugin.
+
+- If this not a JavaScript/TypeScript project, you can should provide an alternative "versionActions" implementation path via the "release.version.versionActions" configuration option.
+`);
+            }
+            throw new Error(`Unable to resolve the "versionActions" implementation for project "${projectGraphNode.name}" at the configured path: "${path}"`);
+        }
+    }
+}
+const versionActionsResolutionCache = new Map();
+async function resolveVersionActionsForProject(tree, releaseGroup, projectGraphNode, finalConfigForProject) {
+    // Project level release version config takes priority, if set
+    const projectVersionConfig = projectGraphNode.data.release?.version;
+    const releaseGroupVersionConfig = releaseGroup.version;
+    const versionActionsPathConfig = projectVersionConfig?.versionActions ??
+        releaseGroupVersionConfig?.versionActions ??
+        null;
+    if (!versionActionsPathConfig) {
+        // Should be an impossible state, as we should have defaulted to the JS implementation during config processing
+        throw new Error(`No versionActions implementation found for project "${projectGraphNode.name}", please report this on https://github.com/nrwl/nx/issues`);
+    }
+    let cachedData = versionActionsResolutionCache.get(versionActionsPathConfig);
+    const versionActionsPath = resolveVersionActionsPath(versionActionsPathConfig, projectGraphNode);
+    let VersionActionsClass;
+    let afterAllProjectsVersioned;
+    if (cachedData) {
+        VersionActionsClass = cachedData.VersionActionsClass;
+        afterAllProjectsVersioned = cachedData.afterAllProjectsVersioned;
+    }
+    else {
+        let cleanupTranspiler;
+        if (versionActionsPath.endsWith('.ts')) {
+            cleanupTranspiler = (0, register_1.registerTsProject)((0, typescript_1.getRootTsConfigPath)());
+        }
+        const loaded = require(versionActionsPath);
+        cleanupTranspiler?.();
+        VersionActionsClass = loaded.default ?? loaded;
+        if (!VersionActionsClass) {
+            throw new Error(`For project "${projectGraphNode.name}" it was not possible to resolve the VersionActions implementation from: "${versionActionsPath}"`);
+        }
+        afterAllProjectsVersioned =
+            loaded.afterAllProjectsVersioned ??
+                // no-op fallback for ecosystems/use-cases where it is not applicable
+                (() => Promise.resolve({
+                    changedFiles: [],
+                    deletedFiles: [],
+                }));
+        versionActionsResolutionCache.set(versionActionsPath, {
+            VersionActionsClass,
+            afterAllProjectsVersioned,
+        });
+    }
+    const versionActions = new VersionActionsClass(releaseGroup, projectGraphNode, finalConfigForProject);
+    // Initialize the version actions with all the required manifest paths etc
+    await versionActions.init(tree);
+    return {
+        versionActionsPath,
+        versionActions,
+        afterAllProjectsVersioned,
+    };
+}
+class VersionActions {
+    constructor(releaseGroup, projectGraphNode, finalConfigForProject) {
+        this.releaseGroup = releaseGroup;
+        this.projectGraphNode = projectGraphNode;
+        this.finalConfigForProject = finalConfigForProject;
+        /**
+         * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
+         * versions and dependencies are determined. If no manifest files should be updated based on the user's
+         * configuration, this will be an empty array.
+         *
+         * The final value for preserveLocalDependencyProtocols will be based on the resolved config for the current
+         * project and any overrides from the user's configuration for the manifestRootsToUpdate.
+         */
+        this.manifestsToUpdate = [];
+    }
+    /**
+     * Asynchronous initialization of the version actions and resolution of manifest paths.
+     * Note: This does NOT validate that manifest files exist - that happens later in validate().
+     */
+    async init(tree) {
+        // Default to the first available source manifest root, if applicable, if no custom manifest roots are provided
+        if (this.validManifestFilenames?.length &&
+            this.finalConfigForProject.manifestRootsToUpdate.length === 0) {
+            for (const manifestFilename of this.validManifestFilenames) {
+                if (tree.exists((0, node_path_1.join)(this.projectGraphNode.data.root, manifestFilename))) {
+                    this.finalConfigForProject.manifestRootsToUpdate.push({
+                        path: this.projectGraphNode.data.root,
+                        preserveLocalDependencyProtocols: this.finalConfigForProject.preserveLocalDependencyProtocols,
+                    });
+                    break;
+                }
+            }
+        }
+        const interpolatedManifestRoots = this.finalConfigForProject.manifestRootsToUpdate.map((manifestRoot) => {
+            return {
+                ...manifestRoot,
+                path: (0, utils_1.interpolate)(manifestRoot.path, {
+                    workspaceRoot: '',
+                    projectRoot: this.projectGraphNode.data.root,
+                    projectName: this.projectGraphNode.name,
+                }),
+            };
+        });
+        // Build manifestsToUpdate but don't validate existence yet as that could break release graph construction before preVersionCommands have run
+        for (const interpolatedManifestRoot of interpolatedManifestRoots) {
+            for (const manifestFilename of this.validManifestFilenames) {
+                const manifestPath = (0, node_path_1.join)(interpolatedManifestRoot.path, manifestFilename);
+                // Just add the first matching filename pattern, actual existence check happens in validate()
+                this.manifestsToUpdate.push({
+                    ...interpolatedManifestRoot,
+                    manifestPath,
+                });
+                break;
+            }
+        }
+    }
+    /**
+     * Validates that manifest files actually exist.
+     * This will be called after all preVersionCommands have run.
+     */
+    async validate(tree) {
+        // Skip if no manifest files are expected
+        if (!this.validManifestFilenames?.length) {
+            return;
+        }
+        // Simply check each manifest exists
+        for (const manifest of this.manifestsToUpdate) {
+            if (!tree.exists(manifest.manifestPath)) {
+                const validManifestFilenames = this.validManifestFilenames?.join(' or ');
+                // Get directory path for error message using Node's path module for cross-platform compatibility
+                let rootPath = manifest.manifestPath;
+                for (const filename of this.validManifestFilenames) {
+                    rootPath = rootPath.replace(filename, '');
+                }
+                throw new Error(`The project "${this.projectGraphNode.name}" does not have a ${validManifestFilenames} file available in ${rootPath}
+
+To fix this you will either need to add a ${validManifestFilenames} file at that location, or configure "release" within your nx.json to exclude "${this.projectGraphNode.name}" from the current release group, or amend the "release.version.manifestRootsToUpdate" configuration to point to where the relevant manifest should be.
+
+It is also possible that the project is being processed because of a dependency relationship between what you are directly versioning and the project/release group, in which case you will need to amend your filters to include all relevant projects and release groups.`);
+            }
+        }
+    }
+    /**
+     * The default implementation will calculate the new version based on semver. If semver is not applicable to a
+     * particular versioning use-case, this method should be overridden with custom logic.
+     *
+     * @param {string | null} currentVersion - The current version of the project, or null if the current version resolver is set to 'none'
+     * @param {string} newVersionInput - The new version input provided by the user, such as a semver relative bump type, or an explicit version
+     * @param {string} newVersionInputReason - The reason for the new version input used to inform the log message to show to the user
+     * @param {Record<string, unknown>} newVersionInputReasonData - The data to interpolate into the new version input reason
+     * @param {string} preid - The preid to use for the new version, if applicable
+     */
+    async calculateNewVersion(currentVersion, newVersionInput, newVersionInputReason, newVersionInputReasonData, preid) {
+        const isSemverRelativeBump = (0, semver_1.isRelativeVersionKeyword)(newVersionInput);
+        const newVersionReasonText = release_group_processor_1.BUMP_TYPE_REASON_TEXT[newVersionInputReason];
+        if (!newVersionReasonText) {
+            throw new Error(`Unhandled bump type reason for ${this.projectGraphNode.name} with newVersionInput ${newVersionInput} and newVersionInputReason ${newVersionInputReason}, please report this as a bug on https://github.com/nrwl/nx/issues`);
+        }
+        const interpolatedNewVersionInputReasonText = (0, utils_1.interpolate)(newVersionReasonText, newVersionInputReasonData);
+        if (isSemverRelativeBump && !currentVersion) {
+            throw new Error(`There was no current version resolved for project "${this.projectGraphNode.name}", but it was configured to be bumped via a semver relative keyword "${newVersionInput}"${interpolatedNewVersionInputReasonText}. This is not a valid combination, please review your release configuration and CLI arguments`);
+        }
+        const newVersion = (0, semver_1.deriveNewSemverVersion)(currentVersion, newVersionInput, preid, {
+            adjustSemverBumpsForZeroMajorVersion: this.finalConfigForProject.adjustSemverBumpsForZeroMajorVersion,
+        });
+        const newVersionInputText = (0, semver_1.isRelativeVersionKeyword)(newVersionInput)
+            ? `semver relative bump "${newVersionInput}"`
+            : `explicit semver value "${newVersionInput}"`;
+        return {
+            newVersion,
+            logText: `❓ Applied ${newVersionInputText}${interpolatedNewVersionInputReasonText}to get new version ${newVersion}`,
+        };
+    }
+    /**
+     * Implementation details of resolving the dependencies of a project.
+     *
+     * The default implementation will read dependencies from the Nx project graph. In many cases this will be sufficient,
+     * because the project graph will have been constructed using plugins from relevant ecosystems that should have applied
+     * any and all relevant metadata to the project nodes and dependency edges.
+     *
+     * If, however, the project graph cannot be used as the source of truth for whatever reason, then this default method
+     * can simply be overridden in the final version actions implementation.
+     */
+    async readDependencies(tree, projectGraph) {
+        return (projectGraph.dependencies[this.projectGraphNode.name] ?? []).filter(
+        // Skip implicit dependencies for now to match legacy versioning behavior
+        // TODO: holistically figure out how to handle implicit dependencies with nx release
+        (dep) => dep.type !== 'implicit');
+    }
+}
+exports.VersionActions = VersionActions;
+class NOOP_VERSION_ACTIONS extends VersionActions {
+    constructor() {
+        super(...arguments);
+        this.validManifestFilenames = null;
+    }
+    async validate(tree) {
+        // Nothing to validate, patch base method
+        return;
+    }
+    readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+        return Promise.resolve(null);
+    }
+    readCurrentVersionFromSourceManifest(tree) {
+        return Promise.resolve(null);
+    }
+    readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+        return Promise.resolve({
+            currentVersion: null,
+            dependencyCollection: null,
+        });
+    }
+    async calculateNewVersion(currentVersion, newVersionInput, newVersionInputReason, newVersionInputReasonData, preid) {
+        return Promise.resolve({
+            newVersion: '0.0.0',
+            logText: 'Skipped default versioning as no-op.',
+        });
+    }
+    updateProjectDependencies(tree, projectGraph, dependenciesToUpdate) {
+        return Promise.resolve([]);
+    }
+    updateProjectVersion(tree, newVersion) {
+        return Promise.resolve([]);
+    }
+}
+exports.NOOP_VERSION_ACTIONS = NOOP_VERSION_ACTIONS;

package/src/command-line/release/version.d.ts

@@ -0,0 +1,26 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { VersionOptions } from './command-object';
+import { ReleaseGraph } from './utils/release-graph';
+import { VersionData } from './utils/shared';
+export interface NxReleaseVersionResult {
+    /**
+     * In one specific (and very common) case, an overall workspace version is relevant, for example when there is
+     * only a single release group in which all projects have a fixed relationship to each other. In this case, the
+     * overall workspace version is the same as the version of the release group (and every project within it). This
+     * version could be a `string`, or it could be `null` if using conventional commits and no changes were detected.
+     *
+     * In all other cases (independent versioning, multiple release groups etc), the overall workspace version is
+     * not applicable and will be `undefined` here. If a user attempts to use this value later when it is `undefined`
+     * (for example in the changelog command), we will throw an appropriate error.
+     */
+    workspaceVersion: (string | null) | undefined;
+    projectsVersionData: VersionData;
+    /**
+     * The release graph that was built or reused during this operation.
+     * This can be passed to subsequent operations (changelog, publish) to avoid recomputing.
+     */
+    releaseGraph: ReleaseGraph;
+}
+export declare const releaseVersionCLIHandler: (args: VersionOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration, ignoreNxJsonConfig: boolean): (args: VersionOptions) => Promise<NxReleaseVersionResult>;
+//# sourceMappingURL=version.d.ts.map

package/src/command-line/release/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/release/version.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,sBAAsB,EAGvB,MAAM,sBAAsB,CAAC;AAU9B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAclD,OAAO,EAAE,YAAY,EAAsB,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EACL,WAAW,EAKZ,MAAM,gBAAgB,CAAC;AAKxB,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;;OASG;IACH,gBAAgB,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IAC9C,mBAAmB,EAAE,WAAW,CAAC;IACjC;;;OAGG;IACH,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,eAAO,MAAM,wBAAwB,GAAI,MAAM,cAAc,oBACC,CAAC;AAE/D,wBAAgB,SAAS,CACvB,qBAAqB,EAAE,sBAAsB,EAC7C,kBAAkB,EAAE,OAAO,IAQzB,MAAM,cAAc,KACnB,OAAO,CAAC,sBAAsB,CAAC,CAwWnC"}