@codefast/cli 0.3.7-canary.0 → 0.3.12

package/README.md

@@ -1,339 +1,100 @@
 # @codefast/cli
 
-Command line interface tools for CodeFast development, built with explicit architecture principles.
+Two tools bundled in one CLI:
 
-## Overview
+| Command       | Purpose                                                                                                                                                                             |
+| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mirror sync` | Regenerate `package.json` `exports` from each package's built `dist/` tree (pnpm workspace packages)                                                                                |
+| `arrange`     | Analyze, dry-run, or apply suggested grouping for long Tailwind class strings inside `cn()` / `tv()` call sites (Tailwind v4–oriented heuristics), or `group` a pasted class string |
 
-The CodeFast CLI is a TypeScript-based command-line tool designed to analyze and validate CodeFast projects. It provides powerful analysis capabilities for TypeScript projects and React component type checking, following explicit architecture guidelines for maintainability, testability, and scalability.
+---
 
-## Features
+## Requirements & Install
 
-- **TypeScript Project Analysis**: Analyze TypeScript codebases and generate detailed statistics
-- **React Component Type Checking**: Validate React component type correspondence across packages
-- **Explicit Architecture**: Clean, maintainable codebase following DDD and SOLID principles
-- **Dependency Injection**: Fully testable with InversifyJS container
-- **Rich CLI Experience**: Colorful output with chalk and comprehensive help system
-
-## Installation
-
-```bash
-# Install globally
-npm install -g @codefast/cli
-
-# Or use with npx
-npx @codefast/cli --help
-```
-
-## Usage
-
-### Available Commands
-
-#### Hello Command
-
-```bash
-codefast hello [options]
-codefast hello --name "Developer"
-```
-
-Simple greeting command for testing CLI functionality.
-
-**Options:**
-
-- `-n, --name <name>`: Name to greet (default: "World")
-
-#### Analyze Command
-
-```bash
-codefast analyze [options]
-codefast analyze --pattern "src/**/*.ts" --config "./tsconfig.json"
-```
-
-Analyze TypeScript project and generate statistics about classes, functions, and interfaces.
-
-**Options:**
-
-- `-p, --pattern <pattern>`: File pattern to analyze (default: "src/**/*.ts")
-- `-c, --config <path>`: Path to tsconfig.json file
-
-**Example Output:**
-
-```text
-🔍 Analyzing TypeScript project...
-✅ Found 45 TypeScript files
-⚠️  Loaded 45 source files for analysis
-📊 Project Statistics:
-  Classes: 12
-  Functions: 89
-  Interfaces: 23
-```
-
-#### Check Component Types Command
+**Node.js ≥ 24** is required.
 
 ```bash
-codefast check-component-types [options]
-codefast check-component-types --packages-dir "packages"
-```
-
-Check React component type correspondence across packages in a monorepo.
+# Global
+pnpm add -g @codefast/cli
 
-**Options:**
-
-- `-d, --packages-dir <dir>`: Packages directory to analyze (default: "packages")
-
-## Architecture
-
-This CLI follows **Explicit Architecture** principles, ensuring clear separation of concerns, testability, and maintainability.
-
-### Directory Structure
-
-```text
-src/
-├── core/                           # Core business logic
-│   └── application/               # Application layer
-│       ├── ports/                 # Interface definitions
-│       │   ├── analysis/          # Analysis service interfaces
-│       │   ├── services/          # Service interfaces
-│       │   └── system/            # System service interfaces
-│       └── use-cases/             # Business workflows
-├── infrastructure/                # Technical implementations
-│   └── adapters/                  # Port implementations
-│       ├── analysis/              # Analysis service adapters
-│       ├── services/              # Service adapters
-│       └── system/                # System service adapters
-├── commands/                      # CLI command handling
-├── di/                           # Dependency injection
-│   └── modules/                  # DI module configurations
-└── index.ts                      # CLI entry point
+# Without a global install
+pnpm dlx @codefast/cli -- --help
 ```
 
-### Architectural Layers
-
-#### 1. Core/Application Layer
-
-Contains business logic and defines interfaces (ports) for external dependencies.
-
-**Use Cases:**
-
-- `AnalyzeProjectUseCase`: Orchestrates TypeScript project analysis
-- `CheckComponentTypesUseCase`: Handles React component type validation
-- `GreetUserUseCase`: Simple greeting functionality
+---
 
-**Ports (Interfaces):**
+## `arrange`
 
-- **Analysis Ports**: `TypeScriptAnalysisPort`, `ComponentAnalysisPort`
-- **Service Ports**: `LoggingServicePort`
-- **System Ports**: `FileSystemSystemPort`, `PathSystemPort`, `UrlSystemPort`
+### Recommended workflow
 
-#### 2. Infrastructure Layer
+1. **`analyze [target]`** — Prints a report (long strings, nested `cn` in `tv`, related notes). No files changed.
+2. **`preview [target]`** — Same transforms as `apply`, but writes nothing. Inspect stdout before touching the tree.
+3. **`apply [target]`** — Writes edits. Run `preview` first.
 
-Implements the ports using concrete technologies and external libraries.
+**Default target** (when path is omitted): `packages/ui/src/components` resolved from `process.cwd()`.
 
-**Adapters:**
+### Useful options
 
-- `TsMorphTypescriptAnalysisAdapter`: TypeScript analysis using ts-morph
-- `ReactComponentAnalysisAdapter`: React component analysis
-- `ChalkLoggingServiceAdapter`: Colored console logging with chalk
-- `FastGlobFileSystemSystemAdapter`: File system operations with fast-glob
-- `NodePathSystemAdapter`: Path operations using Node.js path module
-- `NodeUrlSystemAdapter`: URL operations using Node.js url module
+- **`--with-class-name`** — Append `className` as the last argument to the suggested `cn(...)`.
+- **`--cn-import <spec>`** — Override the module specifier when the tool adds a `cn` import.
 
-#### 3. Commands Layer
+### `group [tokens...]`
 
-Handles CLI interface using the Commander.js framework.
+No filesystem involved — paste a class string, get back a suggested `cn(...)` (or a `tv()`-style array with `--tv`) plus a short buckets summary. Use this to tune your mental model before running `analyze` on a large tree.
 
-- `CommandHandler`: Main command orchestrator with dependency injection
+---
 
-#### 4. Dependency Injection Layer
+## Grouping philosophy — Render Pipeline Order
 
-Manages dependencies using InversifyJS container.
+`arrange` does **not** sort alphabetically. It groups utilities in roughly the same order the browser reasons about them:
 
-**Modules:**
+**Existence → Position → Layout → Sizing → Spacing → Shape → Background → Shadow → Typography → Composite → Motion → Starting → Behavior → Conditions (State)**
 
-- `infrastructureModule`: Binds infrastructure adapters
-- `applicationModule`: Binds use cases and application services
-- `commandsModule`: Binds command handlers
+Bucket breakdown:
 
-### Key Design Principles
+| Bucket         | What it covers                                    | Examples                                          |
+| -------------- | ------------------------------------------------- | ------------------------------------------------- |
+| **Existence**  | Display / containment context                     | `hidden`, `block`, `@container`, `group`, `peer`  |
+| **Position**   | Where the box sits                                | `absolute`, `inset-*`, `top-*`, `z-*`             |
+| **Layout**     | How children flow                                 | `flex`, `grid`, `gap-*`, `items-*`                |
+| **Sizing**     | Box dimensions and overflow                       | `w-*`, `h-*`, `aspect-*`, `overflow-*`            |
+| **Spacing**    | Padding and margin only (gaps stay with Layout)   | `p-*`, `m-*`                                      |
+| **Shape**      | Corners and strokes                               | `rounded-*`, `border-*`, `ring-*`                 |
+| **Background** | Surfaces and masks                                | `bg-*`, `from-*`, `via-*`, `to-*`, `mask-*`       |
+| **Shadow**     | Depth                                             | `shadow-*`, `inset-shadow-*`, `text-shadow-*`     |
+| **Typography** | Text appearance                                   | `font-*`, `text-*`, `leading-*`                   |
+| **Composite**  | Layers and transforms — 3D context → 3D → 2D      | `opacity-*`, `rotate-x-*`, `translate-*`          |
+| **Motion**     | Time-based change                                 | `transition-*`, `animate-*`                       |
+| **Starting**   | Tailwind's `starting:` layer, kept next to Motion | `starting:*`                                      |
+| **Behavior**   | Input / scrolling / chrome                        | `cursor-*`, `scroll-*`, `field-sizing-*`, `inert` |
+| **State**      | Everything with a variant stack                   | `hover:`, `md:`, `@md/sidebar:`, `data-[…]:`      |
 
-1. **Dependency Inversion**: All dependencies flow inward toward the core business logic
-2. **Interface Segregation**: Small, focused interfaces for each concern
-3. **Single Responsibility**: Each class has one reason to change
-4. **Testability**: All dependencies are injected and can be mocked
-5. **Explicit Dependencies**: No hidden dependencies or global state
+Some adjacent buckets may be merged into one string literal when declared _compatible_ (e.g. `layout` + `sizing`) — keeps `cn()` readable without flattening unrelated concerns.
 
-## Development
+To change a placement, edit `classifyBareUtility` in `src/lib/arrange/tokenizer.ts` and add a `classifyToken` test in `src/lib/arrange.test.ts`.
 
-### Prerequisites
+---
 
-- Node.js 20.0.0+
-- pnpm 10.13.1+
+## `mirror sync`
 
-### Setup
+Run from anywhere under the monorepo — the CLI finds the root via `pnpm-workspace.yaml`.
 
 ```bash
-# Install dependencies
-pnpm install
-
-# Build the package
-pnpm build
-
-# Run in development mode
-pnpm dev
-```
-
-### Available Scripts
-
-```bash
-# Development
-pnpm dev                    # Build and watch for changes
-pnpm build                  # Build for production
-pnpm clean                  # Clean build artifacts
-
-# Code Quality
-pnpm lint                   # Run ESLint
-pnpm lint:fix              # Fix ESLint issues
-pnpm type-check            # TypeScript type checking
-pnpm format                # Format code with Prettier
-pnpm format:check          # Check code formatting
-
-# Testing
-pnpm test                  # Run tests
-pnpm test:watch           # Run tests in watch mode
-pnpm test:coverage        # Run tests with coverage
-pnpm test:coverage:ci     # Run tests with CI coverage
-```
-
-### Testing Strategy
-
-The CLI follows a comprehensive testing approach aligned with the explicit architecture:
-
-#### Unit Testing
-
-- **Domain/Application Layer**: Test use cases with mocked ports
-- **Infrastructure Layer**: Test adapters with real or mocked external dependencies
-- **Commands Layer**: Test command handlers with mocked use cases
-
-#### Test Structure
-
-```text
-src/
-├── core/application/use-cases/
-│   ├── analyze-project.use-case.ts
-│   └── analyze-project.use-case.test.ts
-├── infrastructure/adapters/
-│   ├── ts-morph.typescript.analysis.adapter.ts
-│   └── ts-morph.typescript.analysis.adapter.test.ts
-└── commands/
-    ├── command-handler.ts
-    └── command-handler.test.ts
-```
-
-#### Testing Best Practices
-
-- Mock at the port boundaries (interfaces)
-- Use dependency injection for test isolation
-- Test business logic independently of technical details
-- Maintain high coverage for critical paths
-
-### Adding New Features
-
-#### 1. Define the Port (Interface)
-
-```typescript
-// src/core/application/ports/new-feature.port.ts
-export interface NewFeaturePort {
-  performAction(input: string): Promise<string>;
-}
+codefast mirror sync              # All workspace packages
+codefast mirror sync packages/ui  # One package only
+codefast mirror sync -v           # Verbose
 ```
 
-#### 2. Create the Use Case
-
-```typescript
-// src/core/application/use-cases/new-feature.use-case.ts
-@injectable()
-export class NewFeatureUseCase {
-  constructor(
-    @inject(TYPES.NewFeaturePort)
-    private readonly newFeatureService: NewFeaturePort,
-  ) {}
-
-  async execute(input: string): Promise<void> {
-    const result = await this.newFeatureService.performAction(input);
-    // Handle result...
-  }
-}
-```
+**Config:** Place `codefast.config.js` (or `.mjs` / `.cjs` / `.json`) at repo root with a `mirror` object (`skipPackages`, `pathTransformations`, `customExports`, …).
 
-#### 3. Implement the Adapter
-
-```typescript
-// src/infrastructure/adapters/new-feature.adapter.ts
-@injectable()
-export class NewFeatureAdapter implements NewFeaturePort {
-  async performAction(input: string): Promise<string> {
-    // Implementation using external library
-    return `Processed: ${ input }`;
-  }
-}
-```
+> ⚠️ `.js`/`.mjs`/`.cjs` config files are loaded via `import()` — only run `mirror sync` in repositories you trust.
 
-#### 4. Configure Dependency Injection
+---
 
-```typescript
-// src/di/types.ts
-export const TYPES = {
-  // ... existing types
-  NewFeaturePort: Symbol.for('NewFeaturePort'),
-  NewFeatureUseCase: Symbol.for('NewFeatureUseCase'),
-};
+## Developing inside this monorepo
 
-// src/di/modules/infrastructure.module.ts
-infrastructureModule.bind<NewFeaturePort>(TYPES.NewFeaturePort).to(NewFeatureAdapter);
-
-// src/di/modules/application.module.ts
-applicationModule.bind<NewFeatureUseCase>(TYPES.NewFeatureUseCase).to(NewFeatureUseCase);
-```
-
-#### 5. Add CLI Command
-
-```typescript
-// src/commands/command-handler.ts
-this.program.command('new-feature').description('Description of new feature').action(async (options) => {
-  await this.newFeatureUseCase.execute(options.input);
-});
+```bash
+pnpm exec codefast --help
 ```
 
-## Dependencies
-
-### Core Dependencies
-
-- **chalk**: Terminal styling and colors
-- **commander**: CLI framework and argument parsing
-- **fast-glob**: Fast file globbing for file system operations
-- **inversify**: Dependency injection container
-- **reflect-metadata**: Metadata reflection for decorators
-- **ts-morph**: TypeScript compiler API wrapper
-- **zod**: Schema validation and type safety
-
-### Development Dependencies
-
-- **@rslib/core**: Modern build tool for libraries
-- **TypeScript**: Type checking and compilation
-- **Jest**: Testing framework
-- **ESLint**: Code linting
-- **Prettier**: Code formatting
-
-## Contributing
-
-1. Follow the explicit architecture guidelines
-2. Write tests for new features
-3. Ensure all quality checks pass (`pnpm lint`, `pnpm type-check`, `pnpm test`)
-4. Update documentation for new commands or features
-
-## License
-
-MIT License - see LICENSE file for details.
-
-## Related
-
-- [CodeFast UI Components](../ui/README.md)
+Root `package.json` defines optional `cli:*` scripts (e.g. `cli:mirror-sync`, `cli:arrange-analyze`) as thin wrappers around `pnpm exec codefast …`.

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { runCli } from "#program";
+const code = await runCli(process.argv);
+process.exit(code);

package/dist/commands/arrange.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerArrangeCommand(program: Command): void;
+//# sourceMappingURL=arrange.d.ts.map

package/dist/commands/arrange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange.d.ts","sourceRoot":"","sources":["../../src/commands/arrange.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4EzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsF7D"}

package/dist/commands/arrange.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import process from "node:process";
+import { Option } from "commander";
+import { ArrangeError, ArrangeErrorCode, analyzeDirectory, createNodeCliFs, createNodeCliLogger, DEFAULT_ARRANGE_TARGET, formatArray, formatCnCall, printAnalyzeReport, runOnTarget, suggestCnGroups, summarizeGroupBucketLabels, } from "#lib/arrange";
+/** Commander attribute `withClassName` (second long flag `--with-class-name`). */
+function createWithClassNameOption() {
+    return new Option("--with-classname, --with-class-name", "Append className as final cn() argument").default(false);
+}
+function defaultTargetPath() {
+    return path.resolve(process.cwd(), DEFAULT_ARRANGE_TARGET);
+}
+function checkTargetExists(resolved, fs, logger) {
+    if (!fs.existsSync(resolved)) {
+        logger.err(`Not found: ${resolved}`);
+        process.exitCode = 1;
+        return false;
+    }
+    return true;
+}
+function handleArrangeLibError(e, logger) {
+    if (e instanceof ArrangeError && e.code === ArrangeErrorCode.TARGET_NOT_FOUND) {
+        logger.err(e.message);
+        process.exitCode = 1;
+        return true;
+    }
+    return false;
+}
+function runArrangeAction(resolvedTarget, runOpts, fs, logger) {
+    try {
+        runOnTarget(resolvedTarget, {
+            write: runOpts.write,
+            withClassName: !!runOpts.withClassName,
+            cnImport: runOpts.cnImport,
+        }, fs, logger);
+    }
+    catch (e) {
+        if (!handleArrangeLibError(e, logger))
+            throw e;
+    }
+}
+export function registerArrangeCommand(program) {
+    const arrange = program
+        .command("arrange")
+        .description("Analyze and regroup Tailwind classes in cn() / tv() calls (Tailwind v4)");
+    arrange
+        .command("analyze")
+        .description("Report long strings, nested cn in tv(), and related findings")
+        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
+        .action((target) => {
+        const fs = createNodeCliFs();
+        const logger = createNodeCliLogger();
+        const resolved = target ? path.resolve(target) : defaultTargetPath();
+        if (!checkTargetExists(resolved, fs, logger))
+            return;
+        printAnalyzeReport(resolved, analyzeDirectory(resolved, fs), logger);
+    });
+    arrange
+        .command("preview")
+        .description("Dry-run: print suggested replacements without writing files")
+        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
+        .addOption(createWithClassNameOption())
+        .option("--cn-import <spec>", "Override module specifier when adding cn import")
+        .action((target, opts) => {
+        const fs = createNodeCliFs();
+        const logger = createNodeCliLogger();
+        const resolved = target ? path.resolve(target) : defaultTargetPath();
+        if (!checkTargetExists(resolved, fs, logger))
+            return;
+        runArrangeAction(resolved, {
+            write: false,
+            withClassName: opts.withClassName,
+            cnImport: opts.cnImport,
+        }, fs, logger);
+    });
+    arrange
+        .command("apply")
+        .description("Apply grouping and cn-in-tv unwrap edits to files")
+        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
+        .addOption(createWithClassNameOption())
+        .option("--cn-import <spec>", "Override module specifier when adding cn import")
+        .action((target, opts) => {
+        const fs = createNodeCliFs();
+        const logger = createNodeCliLogger();
+        const resolved = target ? path.resolve(target) : defaultTargetPath();
+        if (!checkTargetExists(resolved, fs, logger))
+            return;
+        runArrangeAction(resolved, {
+            write: true,
+            withClassName: opts.withClassName,
+            cnImport: opts.cnImport,
+        }, fs, logger);
+    });
+    arrange
+        .command("group")
+        .description("Try grouping on a pasted class string (stdout: cn(...) or tv array with --tv)")
+        .argument("[tokens...]", "Class tokens (quote a single string if it contains spaces)")
+        .option("--tv", "Emit tv()-style array instead of cn() call", false)
+        .addOption(createWithClassNameOption())
+        .action((tokens, opts) => {
+        const inlineClasses = tokens.join(" ").trim();
+        if (!inlineClasses) {
+            process.stderr.write('Pass a class string. Example: codefast arrange group "flex gap-2 text-sm rounded-md"\n');
+            process.exitCode = 1;
+            return;
+        }
+        const groups = suggestCnGroups(inlineClasses);
+        const result = opts.tv
+            ? formatArray(groups)
+            : formatCnCall(groups, { trailingClassName: !!opts.withClassName });
+        process.stdout.write(`${result}\n`);
+        const bucketSummary = summarizeGroupBucketLabels(groups);
+        process.stdout.write(`\n// Buckets: ${JSON.stringify(bucketSummary)}\n`);
+    });
+}

package/dist/commands/mirror.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function packageArgToRelative(rootDir: string, arg: string | undefined): string | undefined;
+export declare function registerMirrorCommand(program: Command): void;
+//# sourceMappingURL=mirror.d.ts.map

package/dist/commands/mirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mirror.d.ts","sourceRoot":"","sources":["../../src/commands/mirror.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAiBjG;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmC5D"}

package/dist/commands/mirror.js

@@ -0,0 +1,63 @@
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { createNodeCliFs } from "#lib/infra/node-io";
+import { normalizePath, runMirrorSync } from "#lib/mirror";
+import { findRepoRoot } from "#lib/repo-root";
+function tryRealpath(entryPath) {
+    try {
+        return realpathSync.native(entryPath);
+    }
+    catch {
+        return path.resolve(entryPath);
+    }
+}
+export function packageArgToRelative(rootDir, arg) {
+    if (!arg)
+        return undefined;
+    const rootReal = tryRealpath(path.resolve(rootDir));
+    const cwdReal = tryRealpath(process.cwd());
+    const resolved = path.isAbsolute(arg) ? path.resolve(arg) : path.resolve(cwdReal, arg);
+    const targetReal = tryRealpath(resolved);
+    const rel = path.relative(rootReal, targetReal);
+    const normalized = normalizePath(rel);
+    if (normalized.startsWith("..") ||
+        path.isAbsolute(normalized) ||
+        normalized === "" ||
+        normalized === ".") {
+        throw new Error(`Package path must be a subdirectory under monorepo root: ${rootDir}`);
+    }
+    return normalized;
+}
+export function registerMirrorCommand(program) {
+    const mirror = program
+        .command("mirror")
+        .description("Keep package manifests aligned with what you ship");
+    mirror
+        .command("sync")
+        .description("Write package.json exports from dist/ for workspace packages")
+        .argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)")
+        .option("-v, --verbose", "Print extra diagnostics", false)
+        .action(async function (pkg, options) {
+        const globals = this.optsWithGlobals();
+        const fs = createNodeCliFs();
+        const rootDir = findRepoRoot(fs);
+        let packageFilter;
+        try {
+            packageFilter = packageArgToRelative(rootDir, pkg);
+        }
+        catch (e) {
+            this.error(e instanceof Error ? e.message : String(e));
+            return;
+        }
+        const exitCode = await runMirrorSync({
+            rootDir,
+            verbose: options.verbose,
+            /** Commander sets `color: false` when `--no-color` is passed (default `color: true`). */
+            noColor: globals.color === false,
+            packageFilter,
+            fs,
+        });
+        process.exitCode = exitCode;
+    });
+}

package/dist/lib/arrange/analyze.d.ts

@@ -0,0 +1,4 @@
+import type { CliFs } from "#lib/infra/fs-contract";
+import type { AnalyzeReport } from "#lib/arrange/types";
+export declare function analyzeDirectory(target: string, fs: CliFs): AnalyzeReport;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/lib/arrange/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AA8FxD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,GAAG,aAAa,CAsCzE"}