pwa-sv 1.1.1

package/AGENTS-for-pwa.md

@@ -0,0 +1,211 @@
+
+# Functional Programming Guidelines for AI Agents
+
+This document provides explicit instructions for AI agents to follow functional programming paradigms when generating or modifying code. Adhere strictly to these principles.
+
+## Core Functional Programming Principles
+
+### Immutability & Pure Functions
+- **Prefer immutability** - Use immutable data patterns wherever possible
+- **Pure functions** - Functions should not produce side effects and should return the same output for same inputs
+- **Immutable data operations** - Use non-mutating methods for objects and arrays
+
+### Error Handling with Effect Types
+- **NO exceptions** - Use `Effect<T, E>` types from `effect` library instead of throwing errors
+- **Explicit error handling** - All possible errors must be represented in return types
+- **Predictable control flow** - Use `map`, `flatMap`, `match` for error handling chains
+
+### TypeScript-First Development
+- **Proper TypeScript syntax only** - NO JSDoc type annotations allowed
+- **Explicit type annotations** - All functions, parameters, and returns must have TypeScript types
+- **Generic types** - Use TypeScript generics for reusable, type-safe code
+
+## Implementation Rules
+
+### Function Design
+```typescript
+// ✅ CORRECT - Pure function with Effect type
+import { Effect, pipe } from "effect";
+
+const processUser = (user: User): Effect.Effect<ProcessedUser, ValidationError> => {
+  return pipe(
+    Effect.succeed(user),
+    Effect.andThen(validateUser),
+    Effect.map(transformUser),
+    Effect.map(enrichUserData)
+  );
+}
+
+// ❌ INCORRECT - Throws exceptions, mutable parameters
+function processUser(user: User): ProcessedUser {
+  if (!user.valid) throw new Error("Invalid user");
+  user.processed = true; // Mutation!
+  return user;
+}
+```
+
+### State Management in Svelte Components
+```typescript
+// ✅ CORRECT - Svelte reactive declarations with proper typing
+<script lang="ts">
+  // Svelte component state - let is required for reactivity
+  let count = $state<number>(0);
+  let users = $state<ReadonlyArray<User>>([]);
+
+  // Immutable updates to Svelte state
+  const addUser = (newUser: User): void => {
+    users = [...users, newUser]; // ✅ Correct - immutable update
+  };
+
+  const updateUser = (id: string, updates: Partial<User>): void => {
+    users = users.map(user =>
+      user.id === id ? { ...user, ...updates } : user
+    );
+  };
+</script>
+
+// ❌ INCORRECT - Direct mutation of Svelte state
+<script lang="ts">
+  let users = $state<User[]>([]);
+
+  const addUser = (newUser: User): void => {
+    users.push(newUser); // ❌ Mutation - avoid this pattern
+  };
+</script>
+```
+
+### Pure TypeScript Modules (Non-Svelte)
+```typescript
+// ✅ CORRECT - Pure functional module with const
+import { Effect } from "effect";
+
+export const processUsers = (users: ReadonlyArray<User>): Effect.Effect<ReadonlyArray<ProcessedUser>, Error> => {
+  return Effect.gen(function*() {
+    const validUsers = yield* Effect.succeed(users.filter(isValidUser));
+    return yield* Effect.forEach(validUsers, processUser);
+  });
+};
+
+// ❌ INCORRECT - Mutable variables in pure TypeScript
+export let processedUsers: User[] = []; // ❌ Avoid module-level mutable variables
+
+export function addUser(user: User): void {
+  processedUsers.push(user); // ❌ Mutation
+}
+```
+
+### Error Handling Patterns
+```typescript
+// ✅ CORRECT - Using effect
+import { Effect, pipe } from "effect";
+
+const fetchUser = (id: string): Effect.Effect<User, NetworkError | NotFoundError> => {
+  return pipe(
+    Effect.try({
+      try: () => apiCall(id),
+      catch: (error) => error as NetworkError
+    }),
+    Effect.andThen(validateResponse),
+    Effect.map(parseUserData)
+  );
+}
+
+// Usage with proper handling
+const result = pipe(
+  fetchUser('123'),
+  Effect.match({
+    onFailure: (error) => { /* handle error */ },
+    onSuccess: (user) => { /* handle success */ }
+  })
+);
+```
+
+## Svelte 5 Specific Guidelines
+
+### State Management
+- Use `let` with `$state<T>()` for Svelte component reactive state
+- Use immutable patterns when updating Svelte state (spread operator, map, filter)
+- Prefer `readonly` types for state that shouldn't be mutated externally
+- Use `$effect()` for side effects with proper TypeScript typing
+
+### Component Patterns
+```typescript
+// ✅ CORRECT - Functional Svelte component with immutable patterns
+<script lang="ts">
+  // Svelte state declarations use let + $state
+  let count = $state<number>(0);
+  let items = $state<ReadonlyArray<string>>([]);
+
+  // Pure functions for business logic
+  const increment = (): void => {
+    count += 1; // ✅ This is Svelte reactivity, not variable reassignment
+  };
+
+  const addItem = (item: string): void => {
+    items = [...items, item]; // ✅ Immutable update
+  };
+
+  const removeItem = (index: number): void => {
+    items = items.filter((_, i) => i !== index); // ✅ Immutable update
+  };
+
+  $effect(() => {
+    // Side effects here
+    console.log(`Count is: ${count}`);
+  });
+</script>
+```
+
+## Mandatory Checks Before Code Generation
+
+1. **Immutability Check**: No direct mutation of objects/arrays (use spread, map, filter instead)
+2. **Error Handling Check**: All possible errors must return Effect types, no throw statements
+3. **TypeScript Check**: Proper TypeScript syntax, no JSDoc types, explicit return types
+4. **Purity Check**: No side effects in pure functions, all dependencies explicit
+5. **Svelte Context Check**: Use `let` only in Svelte components for reactive state, use `const` elsewhere
+
+## Prohibited Patterns
+
+- ❌ `throw new Error()` (use Effect types instead)
+- ❌ Direct mutation: `array.push()`, `array.splice()`, `object.property = value`
+- ❌ JSDoc `@type`, `@param`, `@return` annotations (use TypeScript syntax)
+- ❌ `let` in pure TypeScript modules (use `const`)
+- ❌ Class inheritance (`extends`) - prefer composition
+
+## Required Patterns
+
+- ✅ `let` + `$state<T>()` for Svelte component reactive state
+- ✅ `const` for all variable declarations outside Svelte components
+- ✅ `Effect<T, E>` from effect for error handling
+- ✅ `map`, `filter`, `reduce` for iteration with immutable updates
+- ✅ TypeScript interface/type definitions
+- ✅ Pure functions with explicit return types
+- ✅ Immutable updates to Svelte state: `array = [...array, newItem]`
+
+## Context-Specific Rules
+
+### In Svelte Components (.svelte files):
+```typescript
+// ✅ REQUIRED - Use let for reactive state
+let count = $state<number>(0);
+let user = $state<User | null>(null);
+
+// ✅ Use const for helper functions
+const calculateTotal = (items: readonly Item[]): number => {
+  return items.reduce((sum, item) => sum + item.price, 0);
+};
+```
+
+### In TypeScript Modules (.ts files):
+```typescript
+// ✅ REQUIRED - Use const for all declarations
+import { Effect } from "effect";
+
+export const DEFAULT_CONFIG = { theme: 'dark' } as const;
+export const processData = (data: Data): Effect.Effect<Output, Error> => {
+  // Pure functional logic using Effect
+  return Effect.succeed(data);
+};
+```
+
+**Remember**: Functional programming principles are maintained through immutable data operations and pure functions, while respecting Svelte's reactive declaration patterns that require `let` for component state.

package/AGENTS.md

@@ -0,0 +1,141 @@
+# AGENTS.md
+
+## 🧠 Agent Instructions
+
+You are OpenCode, an intelligent development agent specializing in TypeScript CLI tools and SvelteKit PWA project automation. Please read and adhere to the guidelines below.
+
+---
+
+### 📌 Core Principles
+
+- **Functional Programming Paradigm**: This project is built with functional programming at its core
+  - Use the **Effect library** (v3.19+) for all error handling
+  - Prefer pure functions with no side effects
+  - Use `Either.Either<Error, T>` for result types
+  - Leverage function composition and higher-order functions
+  - Maintain immutability and avoid direct mutation
+  - Separate pure business logic from I/O side effects
+
+- **TypeScript Strict Mode**:
+  - Always use explicit types (no implicit any)
+  - Enable strict type-checking (`strict: true` in tsconfig.json)
+  - Leverage interfaces and type aliases for clarity
+  - Use `.ts` or `.mts` extensions for all new files
+
+---
+
+### 💻 Execution Environment
+
+- **OS**: Windows 11
+- **Shell**: Windows PowerShell
+- **Node.js**: v24.x (latest LTS with built-in TypeScript support)
+- **Package Manager**: pnpm v10.21.0
+- **TypeScript**: v5.9.3
+
+---
+
+### 📦 Project Context
+
+This is **pwa-sv**, a CLI tool that automates the creation of type-safe Progressive Web App (PWA) projects using SvelteKit.
+
+**Key Modules**:
+- `cli.ts`: Command-line interface using Commander.js
+- `engine.ts`: Core automation pipeline with Effect-based error handling
+- `deps-manager.ts`: Dependency installation using pnpm and execa
+- `process-fs-handler.ts`: File system operations and SvelteKit project creation
+
+**Architecture Pattern**: Pipeline/Filter with transactional integrity
+- Each step in the pipeline returns `Either.Either<void, Error>`
+- Failed steps trigger automatic rollback
+- Pipeline state is tracked immutably
+
+---
+
+### ✅ Best Practices
+
+#### Code Style
+- Use Effect library for all error handling (never use try/catch directly)
+- Functions should return `Either.Either<T, Error>` for operations that can fail
+- Use `Either.isLeft()` and `Either.isRight()` to check results
+- Prefer `Effect.runPromise()` or `Either.match()` for result handling
+- Keep functions small and focused (single responsibility)
+- Use const declarations and immutable data structures
+- Prefer expressions over statements
+
+#### Testing
+- Write tests using Vitest (configured in the project)
+- Create test files alongside source files: `[module-name].test.ts`
+- Test pure functions in isolation
+- Mock I/O operations for integration tests
+
+#### CLI Development
+- Use Commander.js for CLI interface
+- Validate user input before processing
+- Provide helpful error messages
+- Use `chalk` for colored console output (already configured)
+
+#### Dependency Management
+- Always use pnpm for package management
+- Categorize dependencies as runtime or dev dependencies
+- Use `execa` for running external commands
+
+---
+
+### 🚫 Do Not
+
+- Use untyped JavaScript - always use TypeScript
+- Use try/catch blocks for error handling - use Effect library instead
+- Mutate function parameters or external state
+- Use global variables or shared mutable state
+- Install dependencies globally - use pnpm project-local
+- Use `var` declarations - use `const` only
+- Assume external tools are globally installed
+- Write code that directly mutates the file system - use Effect-wrapped operations
+
+---
+
+### 🛠️ Common Patterns
+
+#### Error Handling with Effect
+```typescript
+import { Either } from 'effect';
+
+export const someOperation = async (input: string): Promise<Either.Either<Error, void>> => {
+  try {
+    // Pure logic here
+    return Either.right(void 0);
+  } catch (error: any) {
+    return Either.left(new Error(`Operation failed: ${error.message}`));
+  }
+};
+```
+
+#### Pipeline Step Pattern
+```typescript
+const stepResult = await someOperation(config);
+if (Either.isLeft(stepResult)) {
+  await performRollback(state);
+  return stepResult;
+}
+state.stepCompleted = true;
+```
+
+---
+
+### 📁 File Organization
+
+```
+src/
+├── cli.ts           # CLI entry point (Commander.js)
+├── engine.ts        # Pipeline orchestration
+├── deps-manager.ts  # Dependency operations
+├── process-fs-handler.ts # FS operations
+└── types.ts         # TypeScript interfaces
+
+tests/               # Vitest test files
+docs/                # Architecture documentation
+```
+
+---
+
+Follow these guidelines to maintain functional purity, type safety, and compatibility with the pwa-sv CLI tool architecture.

package/README.md

@@ -0,0 +1,182 @@
+# pwa-sv - Svelte PWA Project Automation Tool
+
+A CLI tool that streamlines the creation of typesafe Progressive Web App (PWA) projects using SvelteKit with a simple `pnpm create pwa-sv` command.
+
+    ![NPM Last Update](https://img.shields.io/npm/last-update/pwa-sv)                                                              │
+│   ![GitLab Last Commit](https://img.shields.io/gitlab/last-commit/EduTherapy%2Fpwa-sv)
+
+## Features
+
+- **Quick Setup**: Create a SvelteKit PWA project with a single command
+- **PWA Ready**: Pre-configured with service worker, manifest, and caching strategies
+- **Vite Integration**: Properly configured PWA plugin for Vite
+- **Package Scripts**: Pre-configured development, build, and preview scripts
+- **Functional Programming Ready**: Includes [Effect](https://effect.website/) library and functional programming patterns
+- **Type-Safe Error Handling**: Uses Effect's powerful error handling capabilities (with compatibility for existing Result patterns)
+- **Optional Features**:
+  - Skeleton UI Framework (with `--skeleton` or `-s` flag)
+  - Internationalization Support (with `--i18n` or `-i` flag)
+  - Dexie IndexedDB Wrapper (with `--dexie` or `-d` flag)
+  - Playwright Browser Testing (with `--playwright` or `-p` flag)
+
+## Installation & Usage
+
+### Creating a New Project
+
+```bash
+pnpm create pwa-sv my-pwa-project
+```
+
+### Using Command-Line Flags
+
+```bash
+# Create project with Skeleton UI
+pnpm create pwa-sv my-pwa-project --skeleton
+# Or using short flag
+pnpm create pwa-sv my-pwa-project -s
+
+# Create project with internationalization support
+pnpm create pwa-sv my-pwa-project --i18n
+# Or using short flag
+pnpm create pwa-sv my-pwa-project -i
+
+# Create project with Dexie for IndexedDB
+pnpm create pwa-sv my-pwa-project --dexie
+# Or using short flag
+pnpm create pwa-sv my-pwa-project -d
+
+# Create project with Playwright browser testing
+pnpm create pwa-sv my-pwa-project --playwright
+# Or using short flag
+pnpm create pwa-sv my-pwa-project -p
+
+# Create project with multiple optional features
+pnpm create pwa-sv my-pwa-project --skeleton --i18n --dexie --playwright
+
+# Use non-interactive mode (accept all defaults)
+pnpm create pwa-sv my-pwa-project --yes
+```
+
+### Additional Options
+
+- **Playwright Testing**: By default, Playwright is not installed. Use the `--playwright` (or `-p`) flag to include Playwright browser testing in your project.
+- **Vitest Defaults**: When unit or component testing is selected, the `--defaults` flag is automatically used to bypass interactive prompts and automatically select both unit and component testing.
+
+## Available Scripts
+
+After project creation, these scripts are available in your `package.json`:
+
+
+- `pnpm build-pwa-assets`: Generate PWA icons and assets
+- `pnpm i18n:extract`: Extract translation keys (if i18n enabled)
+- `pnpm i18n:check`: Check for missing translations (if i18n enabled)
+
+## Project Structure
+
+The generated project follows SvelteKit conventions with additional PWA-specific configurations:
+
+```
+my-pwa-project/
+├── package.json           # Scripts and dependencies configured
+
+├── vite.config.ts        # Vite config with PWA plugin
+├── svelte.config.js      # SvelteKit configuration
+├── tailwind.config.cjs   # Tailwind CSS with Skeleton UI (if enabled)
+├── src/                  # SvelteKit application code
+│   ├── lib/              # Reusable components, modules, etc.
+│   │   ├── i18n/         # Internationalization config (if enabled)
+│   │   └── locales/      # Translation files (if enabled)
+│   ├── routes/           # Page routes
+│   └── app.html          # Application shell
+├── static/               # Static assets directory
+└── Configuration files (tsconfig.json, etc.)
+```
+
+## Configuration
+
+#### PWA Configuration
+
+The `vite.config.ts` file includes the PWA plugin with service worker and manifest configuration. The manifest is automatically configured with default values.
+
+## Internationalization (i18n)
+
+When the `--i18n` flag is used, the project includes:
+
+- `svelte-i18n` for internationalization
+- Pre-configured English and Spanish locale files
+- A sample component showing how to use translations
+- Scripts for extracting and checking translations
+
+## Skeleton UI
+
+When the `--skeleton` flag is used, the project includes:
+
+- Tailwind CSS configured with Skeleton UI
+- Proper component aliases
+- A sample component showing how to use Skeleton UI components
+
+## Functional Programming Features
+
+The generated SvelteKit PWA projects now include support for functional programming patterns using the [Effect](https://effect.website/) library. This provides:
+
+- **Type-safe error handling** with Effect's powerful error management
+- **Resource management** with automatic cleanup capabilities
+- **Concurrent operations** with Effect's concurrency model
+- **Effectful computations** with proper handling of side effects
+- **Development tools** with integrated Effect Platform for comprehensive utilities
+- **Backwards compatibility** with existing Result patterns
+
+For more details on using functional programming in your generated applications, see the [functional programming documentation](./docs/functional-programming.md).
+
+## Contributing
+
+Contributions are welcome! This project was created using a comprehensive development workflow based on user stories and epics to ensure a well-architected, maintainable codebase.
+
+## Publishing
+
+To publish this CLI tool to npm as `pwa-sv`, please follow the steps in the [publishing guide](./docs/publishing-guide.md).
+
+## Recent Changes
+
+### Migration to Effect Library
+The CLI tool has been updated to use the [Effect](https://effect.website/) library instead of neverthrow for functional programming patterns. This provides:
+
+- More powerful functional programming capabilities
+- Better resource management
+- Enhanced error handling
+- Compatibility with existing code
+
+See the [migration documentation](./docs/migration.md) for more details.
+
+### GitLab CI/CD Integration
+Added comprehensive GitLab CI/CD configuration for automated testing, building, and publishing:
+
+- Automated testing on every push and merge request
+- Build verification and artifact storage
+- Automated publishing to npm registries
+- Documentation deployment
+
+See the [publishing guide](./docs/publishing-guide.md) for more information.
+
+## Package Information
+
+This tool is published as [`pwa-sv`](https://www.npmjs.com/package/pwa-sv) on npm. Install it using:
+
+```bash
+pnpm create pwa-sv my-project
+# or
+npm create pwa-sv my-project
+# or
+yarn create pwa-sv my-project
+```
+
+## About EduTherapy
+
+This tool is developed by **EduTherapy** (a brand of Talim Shifa Studio), specializing in digital transformation for education and healthcare sectors through Progressive Web Apps.
+
+- 🌐 Website: https://eduth.pro/
+- 📧 Contact: edutherapystudio@gmail.com
+
+## License
+
+MIT

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,MAiBlD,CAAC"}

package/dist/cli.js

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import { createProject } from './engine.js';
+import { existsSync } from 'fs';
+const program = new Command();
+// Validate project name to ensure it's a valid directory name
+export const validateProjectName = (name) => {
+    if (!name) {
+        throw new Error('Project name is required');
+    }
+    // Check for invalid characters in directory name
+    const invalidChars = /[<>:"/\\|?*]/g;
+    if (invalidChars.test(name)) {
+        throw new Error('Project name contains invalid characters');
+    }
+    // Check for valid NPM package name (simplified)
+    if (name.startsWith('.') || name.startsWith('_')) {
+        throw new Error('Project name cannot start with "." or "_"');
+    }
+    return name;
+};
+// Define the main command
+program
+    .name('pwa-sv')
+    .description('CLI tool to create SvelteKit PWA projects')
+    .version('1.3.0')
+    .argument('<project-name>', 'Name of the project to create')
+    .option('--yes', 'Skip confirmation prompts (CI/CD mode)')
+    .option('-d, --dexie', 'Include Dexie IndexedDB wrapper')
+    .option('-s, --skeleton', 'Add Skeleton UI framework')
+    .option('-i, --i18n', 'Add internationalization support')
+    .option('-p, --playwright', 'Add Playwright for browser testing')
+    .action(async (rawProjectName, options) => {
+    try {
+        // Validate project name
+        const projectName = validateProjectName(rawProjectName);
+        // Check if directory already exists and non-interactive mode is on
+        if (options.yes && existsSync(projectName)) {
+            console.log(`Warning: Directory ${projectName} already exists and will be overwritten.`);
+        }
+        const config = {
+            projectName,
+            useDexie: options.dexie || false,
+            useSkeleton: options.skeleton || false,
+            useI18n: options.i18n || false,
+            usePlaywright: options.playwright || false,
+            nonInteractive: options.yes || false,
+        };
+        await createProject(config);
+    }
+    catch (error) {
+        console.error('Error creating project:', error.message);
+        process.exit(1);
+    }
+});
+// Add help option
+program.showHelpAfterError('(add --help for additional information)');
+program.parse();
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAEhC,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;AAE9B,8DAA8D;AAC9D,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,IAAY,EAAU,EAAE;IAC1D,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;IAC9C,CAAC;IAED,iDAAiD;IACjD,MAAM,YAAY,GAAG,eAAe,CAAC;IACrC,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC9D,CAAC;IAED,gDAAgD;IAChD,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACjD,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF,0BAA0B;AAC1B,OAAO;KACJ,IAAI,CAAC,QAAQ,CAAC;KACd,WAAW,CAAC,2CAA2C,CAAC;KACxD,OAAO,CAAC,OAAO,CAAC;KAChB,QAAQ,CAAC,gBAAgB,EAAE,+BAA+B,CAAC;KAC3D,MAAM,CAAC,OAAO,EAAE,wCAAwC,CAAC;KACzD,MAAM,CAAC,aAAa,EAAE,iCAAiC,CAAC;KACxD,MAAM,CAAC,gBAAgB,EAAE,2BAA2B,CAAC;KACrD,MAAM,CAAC,YAAY,EAAE,kCAAkC,CAAC;KACxD,MAAM,CAAC,kBAAkB,EAAE,oCAAoC,CAAC;KAChE,MAAM,CAAC,KAAK,EAAE,cAAsB,EAAE,OAAY,EAAE,EAAE;IACrD,IAAI,CAAC;QACH,wBAAwB;QACxB,MAAM,WAAW,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAC;QAExD,mEAAmE;QACnE,IAAI,OAAO,CAAC,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YAC3C,OAAO,CAAC,GAAG,CAAC,sBAAsB,WAAW,0CAA0C,CAAC,CAAC;QAC3F,CAAC;QAED,MAAM,MAAM,GAAY;YACtB,WAAW;YACX,QAAQ,EAAE,OAAO,CAAC,KAAK,IAAI,KAAK;YAChC,WAAW,EAAE,OAAO,CAAC,QAAQ,IAAI,KAAK;YACtC,OAAO,EAAE,OAAO,CAAC,IAAI,IAAI,KAAK;YAC9B,aAAa,EAAE,OAAO,CAAC,UAAU,IAAI,KAAK;YAC1C,cAAc,EAAE,OAAO,CAAC,GAAG,IAAI,KAAK;SACrC,CAAC;QAEF,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;QACxD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC,CAAC,CAAC;AAEL,kBAAkB;AAClB,OAAO,CAAC,kBAAkB,CAAC,yCAAyC,CAAC,CAAC;AACtE,OAAO,CAAC,KAAK,EAAE,CAAC"}

package/dist/deps-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps-manager.d.ts","sourceRoot":"","sources":["../src/deps-manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAkBhC;;;;GAIG;AACH,QAAA,MAAM,mBAAmB,GAAI,QAAQ,OAAO,KAAG,MAAM,EA8BpD,CAAC;AAEF;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,EAAE,KAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAsBjG,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAU,QAAQ,OAAO,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAsC7F,CAAC"}