@muverse/core 0.1.0

package/dist/services/verse-runner.js

@@ -0,0 +1,182 @@
+import { logger } from "../utils/logger.js";
+import { VersionManager } from "./version-manager.js";
+import { createModuleSystemFactory } from "../factories/module-system-factory.js";
+import { isWorkingDirectoryClean } from "../git/index.js";
+// Service imports
+import { ConfigurationLoader } from "./configuration-loader.js";
+import { CommitAnalyzer } from "./commit-analyzer.js";
+import { VersionBumper } from "./version-bumper.js";
+import { VersionApplier, } from "./version-applier.js";
+import { ChangelogGenerator } from "./changelog-generator.js";
+import { GitOperations } from "./git-operations.js";
+import { AdapterMetadataProvider } from "./adapter-metadata-provider.js";
+import { createAdapterIdentifierRegistry } from "../factories/adapter-identifier-registry.js";
+import { ConfigurationValidator } from "./configuration-validator.js";
+import { banner } from "../utils/banner.js";
+export class VerseRunner {
+    moduleSystemFactory; // Will be initialized in run()
+    moduleRegistry; // Will be initialized in run()
+    versionManager; // Will be initialized in run()
+    config; // Will be initialized in run()
+    adapter; // Will be initialized in run()
+    options;
+    // Service instances
+    configurationLoader;
+    commitAnalyzer;
+    versionBumper; // Will be initialized in run()
+    versionApplier; // Will be initialized in run()
+    changelogGenerator;
+    gitOperations; // Will be initialized in run()
+    adapterIdentifierRegistry;
+    adapterMetadataProvider;
+    constructor(options) {
+        this.options = options;
+        // Initialize services
+        this.configurationLoader = new ConfigurationLoader(new ConfigurationValidator());
+        this.changelogGenerator = new ChangelogGenerator({
+            generateChangelog: options.generateChangelog,
+            repoRoot: options.repoRoot,
+            dryRun: options.dryRun,
+        });
+        this.adapterIdentifierRegistry = createAdapterIdentifierRegistry();
+        this.adapterMetadataProvider = new AdapterMetadataProvider(this.adapterIdentifierRegistry, {
+            repoRoot: options.repoRoot,
+            adapter: options.adapter,
+        });
+    }
+    logStartupInfo() {
+        logger.info(banner);
+        logger.info("🌌 Version Engine for Repo Semantic Evolution");
+        logger.info("   Orchestrating your monorepo multiverse...");
+        logger.info("");
+        logger.info("🚀 Starting μVERSE engine...");
+        logger.info(`Repository: ${this.options.repoRoot}`);
+        logger.info(`Adapter: ${this.options.adapter || "(auto-detect)"}`);
+        logger.info(`Dry run: ${this.options.dryRun}`);
+        logger.info(`Prerelease mode: ${this.options.prereleaseMode}`);
+        if (this.options.prereleaseMode) {
+            logger.info(`Prerelease ID: ${this.options.prereleaseId}`);
+            logger.info(`Bump unchanged modules: ${this.options.bumpUnchanged}`);
+        }
+        logger.info(`Add build metadata: ${this.options.addBuildMetadata}`);
+        logger.info(`Timestamp versions: ${this.options.timestampVersions}`);
+        logger.info(`Append snapshot: ${this.options.appendSnapshot}`);
+        logger.info(`Push changes: ${this.options.pushChanges}`);
+        logger.info(`Generate changelog: ${this.options.generateChangelog}`);
+        logger.info("🏃 Running μVERSE semantic evolution...");
+    }
+    logShutdownInfo(result) {
+        if (!result)
+            return;
+        if (result.bumped) {
+            logger.info(`✅ Successfully updated ${result.changedModules.length} modules`);
+            for (const module of result.changedModules) {
+                logger.info(`  ${module.id}: ${module.from} → ${module.to} (${module.bumpType})`);
+            }
+            if (result.createdTags.length > 0) {
+                logger.info(`🏷️  Created ${result.createdTags.length} tags: ${result.createdTags.join(", ")}`);
+            }
+            if (result.changelogPaths.length > 0) {
+                logger.info(`📚 Generated ${result.changelogPaths.length} changelog files`);
+            }
+        }
+        else {
+            logger.info("✨ No version changes needed");
+        }
+        logger.info("");
+        logger.info("🎯 μVERSE completed successfully!");
+        logger.info("   Your multiverse has evolved semantically ✨");
+    }
+    async run() {
+        this.logStartupInfo();
+        let result = null;
+        try {
+            result = await this.doRun();
+            return result;
+        }
+        finally {
+            // Any cleanup if needed
+            this.logShutdownInfo(result);
+        }
+    }
+    async doRun() {
+        this.adapter = await this.adapterMetadataProvider.getMetadata();
+        // Initialize module system factory with resolved adapter
+        this.moduleSystemFactory = createModuleSystemFactory(this.adapter.id, this.options.repoRoot);
+        // Load configuration
+        this.config = await this.configurationLoader.load(this.options.repoRoot);
+        // Check if working directory is clean
+        if (!this.options.dryRun &&
+            !isWorkingDirectoryClean({ cwd: this.options.repoRoot })) {
+            throw new Error("Working directory is not clean. Please commit or stash your changes.");
+        }
+        // Discover modules and get hierarchy manager
+        logger.info("🔍 Discovering modules...");
+        const detector = this.moduleSystemFactory.createDetector();
+        this.moduleRegistry = await detector.detect();
+        // Log discovered modules through hierarchy manager
+        const moduleIds = this.moduleRegistry.getModuleIds();
+        logger.info(`Found ${moduleIds.length} modules: ${moduleIds.join(", ")}`);
+        // Analyze commits since last release
+        this.commitAnalyzer = new CommitAnalyzer(this.moduleRegistry, this.options.repoRoot);
+        const moduleCommits = await this.commitAnalyzer.analyzeCommitsSinceLastRelease();
+        // Initialize version bumper service
+        const versionBumperOptions = {
+            prereleaseMode: this.options.prereleaseMode,
+            bumpUnchanged: this.options.bumpUnchanged,
+            addBuildMetadata: this.options.addBuildMetadata,
+            appendSnapshot: this.options.appendSnapshot,
+            adapter: this.adapter,
+            timestampVersions: this.options.timestampVersions,
+            prereleaseId: this.options.prereleaseId,
+            repoRoot: this.options.repoRoot,
+            config: this.config,
+        };
+        this.versionBumper = new VersionBumper(this.moduleRegistry, versionBumperOptions);
+        // Calculate version bumps with cascade effects
+        const processedModuleChanges = await this.versionBumper.calculateVersionBumps(moduleCommits);
+        const discoveredModules = Array.from(this.moduleRegistry.getModules().values());
+        if (processedModuleChanges.length === 0) {
+            logger.info("✨ No version changes needed");
+            return {
+                bumped: false,
+                discoveredModules,
+                changedModules: [],
+                createdTags: [],
+                changelogPaths: [],
+            };
+        }
+        // Create version manager
+        const versionUpdateStrategy = this.moduleSystemFactory.createVersionUpdateStrategy();
+        this.versionManager = new VersionManager(this.moduleRegistry, versionUpdateStrategy);
+        // Initialize version applier and apply changes
+        const versionApplierOptions = {
+            dryRun: this.options.dryRun,
+        };
+        this.versionApplier = new VersionApplier(this.versionManager, versionApplierOptions);
+        const changedModules = await this.versionApplier.applyVersionChanges(processedModuleChanges);
+        // Generate changelogs
+        const changelogPaths = await this.changelogGenerator.generateChangelogs(changedModules, moduleCommits);
+        // Initialize git operations service
+        const gitOperationsOptions = {
+            pushChanges: this.options.pushChanges,
+            pushTags: this.options.pushTags,
+            repoRoot: this.options.repoRoot,
+            dryRun: this.options.dryRun,
+            isTemporaryVersion: this.options.prereleaseMode || this.options.appendSnapshot,
+        };
+        this.gitOperations = new GitOperations(gitOperationsOptions);
+        // Commit and push changes
+        await this.gitOperations.commitAndPushChanges(changedModules);
+        // Create and push tags
+        const createdTags = await this.gitOperations.createAndPushTags(changedModules);
+        logger.info("✅ μVERSE semantic evolution completed successfully!");
+        return {
+            bumped: true,
+            discoveredModules,
+            changedModules,
+            createdTags,
+            changelogPaths,
+        };
+    }
+}

package/dist/services/version-applier.d.ts

@@ -0,0 +1,26 @@
+import { VersionManager } from "./version-manager.js";
+import { BumpType } from "../semver/index.js";
+import { ProcessedModuleChange } from "./version-bumper.js";
+export type VersionApplierOptions = {
+    dryRun: boolean;
+};
+export type ModuleChangeResult = {
+    readonly id: string;
+    readonly name: string;
+    readonly path: string;
+    readonly type: "module" | "root";
+    readonly from: string;
+    readonly to: string;
+    readonly bumpType: BumpType;
+    readonly declaredVersion: boolean;
+};
+export declare class VersionApplier {
+    private readonly versionManager;
+    private readonly options;
+    constructor(versionManager: VersionManager, options: VersionApplierOptions);
+    applyVersionChanges(processedModuleChanges: ProcessedModuleChange[]): Promise<ModuleChangeResult[]>;
+    private logPlannedChanges;
+    private stageVersions;
+    private commitVersions;
+}
+//# sourceMappingURL=version-applier.d.ts.map

package/dist/services/version-applier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-applier.d.ts","sourceRoot":"","sources":["../../src/services/version-applier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAgB,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF,qBAAa,cAAc;IAEvB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,qBAAqB;IAG3C,mBAAmB,CACvB,sBAAsB,EAAE,qBAAqB,EAAE,GAC9C,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAyChC,OAAO,CAAC,iBAAiB;YAeX,aAAa;YAWb,cAAc;CAM7B"}

package/dist/services/version-applier.js

@@ -0,0 +1,63 @@
+import { logger } from "../utils/logger.js";
+import { formatSemVer } from "../semver/index.js";
+export class VersionApplier {
+    versionManager;
+    options;
+    constructor(versionManager, options) {
+        this.versionManager = versionManager;
+        this.options = options;
+    }
+    async applyVersionChanges(processedModuleChanges) {
+        if (processedModuleChanges.length === 0) {
+            logger.info("✨ No version changes to apply");
+            return [];
+        }
+        logger.info("🔍 Filtering modules with declared versions...");
+        const modulesWithDeclaredVersions = processedModuleChanges.filter((change) => change.module.declaredVersion);
+        if (modulesWithDeclaredVersions.length === 0) {
+            logger.info("✨ No modules with declared versions to update");
+            return [];
+        }
+        this.logPlannedChanges(modulesWithDeclaredVersions);
+        if (this.options.dryRun) {
+            logger.info("🏃‍♂️ Dry run mode - version changes will not be written to files");
+        }
+        else {
+            await this.stageVersions(modulesWithDeclaredVersions);
+            await this.commitVersions();
+        }
+        // Create and return result objects
+        return processedModuleChanges.map((change) => ({
+            id: change.module.id,
+            name: change.module.name,
+            path: change.module.path,
+            type: change.module.type,
+            from: formatSemVer(change.fromVersion),
+            to: change.toVersion,
+            bumpType: change.bumpType,
+            declaredVersion: change.module.declaredVersion,
+        }));
+    }
+    logPlannedChanges(processedModuleChanges) {
+        logger.info(`📈 Planning to update ${processedModuleChanges.length} modules:`);
+        for (const change of processedModuleChanges) {
+            const from = formatSemVer(change.fromVersion);
+            const to = change.toVersion;
+            logger.info(`  ${change.module.id}: ${from} → ${to} (${change.bumpType}, ${change.reason})`);
+        }
+    }
+    async stageVersions(processedModuleChanges) {
+        logger.info("✍️ Staging new versions...");
+        for (const change of processedModuleChanges) {
+            // Use toVersion directly (now includes all transformations like Gradle snapshots)
+            this.versionManager.updateVersion(change.module.id, change.toVersion);
+            logger.info(`  Staged ${change.module.id} to ${change.toVersion}`);
+        }
+    }
+    async commitVersions() {
+        logger.info("💾 Committing version updates to files...");
+        const pendingUpdatesCount = this.versionManager.getPendingUpdatesCount();
+        await this.versionManager.commit();
+        logger.info(`✅ Committed ${pendingUpdatesCount} version updates`);
+    }
+}

package/dist/services/version-bumper.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Version Bumper Service for μVERSE.
+ * Implements core version calculation logic: analyzes commits, cascades changes through
+ * dependencies, and applies versions with support for prereleases, metadata, and snapshots.
+ */
+import { Config } from "../config/index.js";
+import { ModuleRegistry } from "./module-registry.js";
+import { BumpType } from "../semver/index.js";
+import { CommitInfo } from "../git/index.js";
+import { SemVer } from "semver";
+import { AdapterMetadata } from "./adapter-identifier.js";
+import { Module } from "../adapters/project-information.js";
+/**
+ * Configuration options for the version bumper service.
+ */
+export type VersionBumperOptions = {
+    /** Whether to generate prerelease versions (e.g., 1.0.0-alpha.1). */
+    prereleaseMode: boolean;
+    /** Whether to bump versions of unchanged modules in prerelease mode. */
+    bumpUnchanged: boolean;
+    /** Whether to add build metadata (commit SHA) to versions. */
+    addBuildMetadata: boolean;
+    /** Whether to append -SNAPSHOT suffix for Gradle projects. */
+    appendSnapshot: boolean;
+    /** Adapter metadata providing project-specific capabilities. */
+    adapter: AdapterMetadata;
+    /** Whether to include timestamps in prerelease identifiers. */
+    timestampVersions: boolean;
+    /** Base prerelease identifier (e.g., 'alpha', 'beta', 'rc'). */
+    prereleaseId: string;
+    /** Absolute path to the repository root directory. */
+    repoRoot: string;
+    /** Project configuration including dependency bump rules. */
+    config: Config;
+};
+/**
+ * Final processed module version change result.
+ * Represents a completed version calculation ready for application.
+ */
+export type ProcessedModuleChange = {
+    /** The module with calculated version change. */
+    readonly module: Module;
+    /** Original semantic version before changes. */
+    readonly fromVersion: SemVer;
+    /** New calculated version string (e.g., '1.1.0', '1.1.0-alpha.1', '1.1.0-SNAPSHOT'). */
+    readonly toVersion: string;
+    /** Final bump type applied ('major', 'minor', 'patch', or 'none'). */
+    readonly bumpType: BumpType;
+    /** Reason for version change. */
+    readonly reason: ChangeReason;
+};
+/**
+ * Reason why a module's version is being changed.
+ */
+export type ChangeReason = "commits" | "dependency" | "cascade" | "prerelease-unchanged" | "build-metadata" | "gradle-snapshot";
+/**
+ * Service for calculating version bumps across modules.
+ * Handles commit analysis, dependency cascade effects, and various versioning strategies
+ * (regular, prerelease, snapshot).
+ */
+export declare class VersionBumper {
+    private readonly moduleRegistry;
+    private readonly options;
+    /**
+     * Creates a new VersionBumper instance.
+     * @param moduleRegistry - Registry containing all modules and their interdependencies
+     * @param options - Configuration options controlling version bump behavior
+     */
+    constructor(moduleRegistry: ModuleRegistry, options: VersionBumperOptions);
+    /**
+     * Calculates version bumps for all modules based on their commits.
+     * Orchestrates a three-phase process: initial bumps (commit analysis), cascade effects (dependency propagation),
+     * and version application (applying strategies like prerelease, timestamps, build metadata).
+     * @param moduleCommits - Map of module IDs to their commits since last version
+     * @returns Promise resolving to array of processed module changes (only modules that need updates)
+     * @throws {Error} If git operations fail
+     */
+    calculateVersionBumps(moduleCommits: Map<string, CommitInfo[]>): Promise<ProcessedModuleChange[]>;
+    /**
+     * Calculates initial version bump types for all modules based on commits.
+     *
+     * This is Phase 1 of the version calculation process. It analyzes commits for each
+     * module to determine the required version bump type using Conventional Commits
+     * specification.
+     *
+     * The method creates a `ProcessingModuleChange` for **every** module in the registry,
+     * not just those with commits. The `needsProcessing` flag determines which modules
+     * will ultimately be updated.
+     *
+     * **Processing Decision Logic**:
+     * - Module has commits requiring bump: `needsProcessing = true, reason = 'commits'`
+     * - Prerelease mode with bumpUnchanged: `needsProcessing = true, reason = 'prerelease-unchanged'`
+     * - Build metadata enabled: `needsProcessing = true, reason = 'build-metadata'`
+     * - Otherwise: `needsProcessing = false, reason = 'unchanged'`
+     *
+     * @param moduleCommits - Map of module IDs to their commits since last version.
+     *
+     * @returns Array of processing module changes for all modules in the registry
+     */
+    private calculateInitialBumps;
+    /**
+     * Calculates cascade effects when modules change.
+     *
+     * This is Phase 2 of the version calculation process. It propagates version changes
+     * through the module dependency graph, ensuring that when a module changes, all
+     * modules that depend on it are also bumped appropriately.
+     *
+     * **Algorithm**: Uses a breadth-first traversal of the dependency graph:
+     * 1. Start with all modules marked for processing (needsProcessing = true)
+     * 2. For each module being processed, find all modules that depend on it
+     * 3. Calculate required bump for dependents using dependency bump rules
+     * 4. If dependent needs a higher bump, update it and add to processing queue
+     * 5. Continue until no more cascades are needed
+     *
+     * **Complexity**: O(V + E) where V = number of modules, E = number of dependencies
+     *
+     * **In-Place Modification**: This method modifies the input array in place for
+     * efficiency. The same array reference is returned with cascade effects applied.
+     *
+     * @param allModuleChanges - Array of all module changes (will be modified in place).
+     *                          Should include all modules from calculateInitialBumps().
+     *
+     * @returns The same array with cascade effects applied
+     */
+    private calculateCascadeEffects;
+    /**
+     * Applies version calculations and transformations to all modules.
+     *
+     * This is Phase 3 (final) of the version calculation process. It takes modules
+     * with calculated bump types and applies version transformations including:
+     * - Semantic version bumping (major, minor, patch)
+     * - Prerelease version generation
+     * - Build metadata appending
+     * - Snapshot suffix appending
+     *
+     * **Version Application Scenarios**:
+     * 1. **Commits + Regular Mode**: Bump semantic version normally
+     * 2. **Commits + Prerelease Mode**: Bump to prerelease version
+     * 3. **No Commits + Prerelease + bumpUnchanged**: Force prerelease bump
+     * 4. **Build Metadata Mode**: Append git SHA as metadata
+     * 5. **Snapshot Mode**: Append -SNAPSHOT suffix
+     *
+     * @param processingModuleChanges - All module changes with calculated bump types
+     *                                 from cascade effects phase.
+     *
+     * @param effectivePrereleaseId - Prerelease identifier to use (may include timestamp).
+     *                               Example: 'alpha', 'alpha.20251021143022'
+     *
+     * @param shortSha - Optional git commit short SHA for build metadata.
+     *                  Example: 'a1b2c3d'
+     *
+     * @returns Array of processed module changes ready for application (only modules with needsProcessing = true)
+     */
+    private applyVersionCalculations;
+}
+//# sourceMappingURL=version-bumper.d.ts.map

package/dist/services/version-bumper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-bumper.d.ts","sourceRoot":"","sources":["../../src/services/version-bumper.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,MAAM,EAAyB,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAOL,QAAQ,EACT,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,UAAU,EAA4B,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,qEAAqE;IACrE,cAAc,EAAE,OAAO,CAAC;IACxB,wEAAwE;IACxE,aAAa,EAAE,OAAO,CAAC;IACvB,8DAA8D;IAC9D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,8DAA8D;IAC9D,cAAc,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,OAAO,EAAE,eAAe,CAAC;IACzB,+DAA+D;IAC/D,iBAAiB,EAAE,OAAO,CAAC;IAC3B,gEAAgE;IAChE,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsBF;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,iDAAiD;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wFAAwF;IACxF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,iCAAiC;IACjC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,SAAS,GACT,YAAY,GACZ,SAAS,GACT,sBAAsB,GACtB,gBAAgB,GAChB,iBAAiB,CAAC;AAEtB;;;;GAIG;AACH,qBAAa,aAAa;IAOtB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B;;;;OAIG;gBAEgB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,oBAAoB;IAGhD;;;;;;;OAOG;IACG,qBAAqB,CACzB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,GACvC,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAuCnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,qBAAqB;IA6C7B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,uBAAuB;IAgG/B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,wBAAwB;CAgFjC"}