@swissjs/swite 0.3.0

package/dist/utils/file-path-resolver.js

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { findWorkspaceRoot } from "./workspace.js";
+import { findSwissLibMonorepo } from "./package-finder.js";
+/**
+ * Resolve file path from URL, handling SWISS packages, workspace packages, and app files
+ */
+export async function resolveFilePath(url, root, workspaceRoot = null) {
+    // /node_modules/ URLs: walk up from app root until we find the package.
+    // pnpm may place deps at the app root, one level up (workspace pkg), or at
+    // the monorepo root depending on hoisting config and pnpm version.
+    if (url.startsWith("/node_modules/")) {
+        const urlPath = url.startsWith("/") ? url.slice(1) : url;
+        // Walk up the directory tree from root, trying node_modules at each level
+        let current = path.resolve(root);
+        const visited = new Set();
+        for (let i = 0; i < 8; i++) {
+            const candidate = path.join(current, urlPath);
+            if (!visited.has(candidate)) {
+                visited.add(candidate);
+                try {
+                    const resolved = await fs.realpath(candidate);
+                    await fs.access(resolved);
+                    return resolved;
+                }
+                catch {
+                    // try parent level
+                }
+            }
+            const parent = path.dirname(current);
+            if (parent === current)
+                break; // filesystem root
+            current = parent;
+        }
+        // Explicit workspace root (covers hoisted-to-root installs)
+        const wsRoot = workspaceRoot || (await findWorkspaceRoot(root));
+        if (wsRoot) {
+            const wsPath = path.join(wsRoot, urlPath);
+            if (!visited.has(wsPath)) {
+                try {
+                    const resolved = await fs.realpath(wsPath);
+                    await fs.access(resolved);
+                    return resolved;
+                }
+                catch {
+                    // not found there either
+                }
+            }
+        }
+        return path.join(path.resolve(root), urlPath); // fallback; handler will 404
+    }
+    // Check if this is a swiss-lib package file
+    if (url.startsWith("/swiss-packages/")) {
+        // Dynamically find swiss-lib monorepo instead of hardcoded paths
+        const swissLib = await findSwissLibMonorepo(root);
+        if (swissLib) {
+            // Remove /swiss-packages prefix and use the rest as relative path
+            const relativePath = url.replace(/^\/swiss-packages\//, "");
+            const swissPackagesPath = path.join(swissLib, "packages");
+            const fullPath = path.join(swissPackagesPath, relativePath);
+            try {
+                await fs.access(fullPath);
+                console.log(`[file-path-resolver] Found swiss-lib package at: ${fullPath}`);
+                return fullPath;
+            }
+            catch {
+                console.warn(`[file-path-resolver] swiss-lib package file not found: ${fullPath}`);
+                return fullPath; // Return path anyway, will error later if needed
+            }
+        }
+        else {
+            // Fallback: construct path from root (may not work, but better than nothing)
+            const relativePath = url.replace(/^\/swiss-packages\//, "");
+            const fallbackPath = path.join(root, "..", "..", "..", "swiss-lib", "packages", relativePath);
+            console.warn(`[file-path-resolver] swiss-lib not found, using fallback: ${fallbackPath}`);
+            return fallbackPath;
+        }
+    }
+    // Workspace-level directories: always resolve from workspace root
+    // Updated: lib/ now contains all packages (moved from packages/)
+    if (url.startsWith("/lib/") ||
+        url.startsWith("/libraries/") ||
+        url.startsWith("/packages/") ||
+        url.startsWith("/modules/")) {
+        let wsRoot = workspaceRoot;
+        if (!wsRoot) {
+            wsRoot = await findWorkspaceRoot(root);
+            console.log(`[file-path-resolver] Detected workspace root: ${wsRoot} (from app root: ${root})`);
+        }
+        // Normalize URL: path.join with leading slash is wrong on Windows (treats as drive root)
+        const urlPath = url.startsWith("/") ? url.slice(1) : url;
+        // CRITICAL: For /lib/ paths, we MUST find the SWS root (which has lib/ directory)
+        // Start from app root and walk up until we find a directory with both pnpm-workspace.yaml AND lib/
+        if (url.startsWith("/lib/")) {
+            let current = root;
+            for (let i = 0; i < 10; i++) {
+                const workspaceFile = path.join(current, "pnpm-workspace.yaml");
+                const libDir = path.join(current, "lib");
+                try {
+                    await fs.access(workspaceFile);
+                    await fs.access(libDir);
+                    // Found SWS root!
+                    const resolved = path.join(current, urlPath);
+                    console.log(`[file-path-resolver] Found SWS root with lib/: ${current}`);
+                    console.log(`[file-path-resolver] Resolving ${url} from SWS root: ${current} -> ${resolved}`);
+                    return resolved;
+                }
+                catch {
+                    // Continue searching up
+                }
+                const parent = path.dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+        }
+        // For other paths, use detected workspace root
+        if (wsRoot) {
+            let resolved = path.join(wsRoot, urlPath);
+            // Dev fallback: if URL is /packages/.../dist/... and file doesn't exist, try src/ (unbuilt workspace packages)
+            if ((url.startsWith("/packages/") || url.startsWith("/lib/")) &&
+                url.includes("/dist/")) {
+                try {
+                    await fs.access(resolved);
+                }
+                catch {
+                    const srcUrl = urlPath.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+                    const srcResolved = path.join(wsRoot, srcUrl);
+                    try {
+                        await fs.access(srcResolved);
+                        console.log(`[file-path-resolver] dist not found, serving src: ${resolved} -> ${srcResolved}`);
+                        return srcResolved;
+                    }
+                    catch {
+                        // Keep original resolved; handler will 404
+                    }
+                }
+            }
+            console.log(`[file-path-resolver] Resolving ${url} from workspace root: ${wsRoot} -> ${resolved}`);
+            return resolved;
+        }
+        else {
+            console.warn(`[file-path-resolver] No workspace root found, using app root: ${root}`);
+            return path.join(root, urlPath);
+        }
+    }
+    // For app files, check if URL already includes the app path
+    const wsRoot = workspaceRoot || (await findWorkspaceRoot(root));
+    if (wsRoot) {
+        const appRelativeToWorkspace = path
+            .relative(wsRoot, root)
+            .replace(/\\/g, "/");
+        if (url.startsWith(`/${appRelativeToWorkspace}/`)) {
+            // URL already includes app path, use workspace root
+            return path.join(wsRoot, url);
+        }
+        else if (url.startsWith("/src/") ||
+            url.startsWith("/public/") ||
+            url.startsWith("/assets/")) {
+            // App-specific paths (src/, public/, assets/) - resolve from app root
+            return path.join(root, url);
+        }
+        else if (url.startsWith("/")) {
+            // Other absolute URLs, try workspace root first, then app root
+            const workspacePath = path.join(wsRoot, url);
+            try {
+                await fs.access(workspacePath);
+                return workspacePath;
+            }
+            catch {
+                return path.join(root, url);
+            }
+        }
+        else {
+            // Relative to app root
+            return path.join(root, url);
+        }
+    }
+    else {
+        return path.join(root, url);
+    }
+}

package/dist/utils/generate-import-map-cli.d.ts

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

package/dist/utils/generate-import-map-cli.d.ts.map

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

package/dist/utils/generate-import-map-cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * CLI tool to generate import maps
+ * Licensed under the MIT License.
+ */
+import { generateImportMap, saveImportMap } from "./generate-import-map.js";
+import { findWorkspaceRoot } from "./workspace.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function main() {
+    // Find app root (where swite is running from)
+    // This script is typically run from the app directory
+    const appRoot = process.cwd();
+    const workspaceRoot = await findWorkspaceRoot(appRoot);
+    console.log(`[ImportMap] App root: ${appRoot}`);
+    console.log(`[ImportMap] Workspace root: ${workspaceRoot || "none"}`);
+    // Generate import map
+    const importMap = await generateImportMap(appRoot, workspaceRoot);
+    // Save to .swite/import-map.json in app root
+    const outputPath = path.join(appRoot, ".swite", "import-map.json");
+    await saveImportMap(importMap, outputPath);
+    console.log(`[ImportMap] ✅ Import map generated successfully`);
+    process.exit(0);
+}
+main().catch((error) => {
+    console.error("[ImportMap] Error:", error);
+    process.exit(1);
+});

package/dist/utils/generate-import-map.d.ts

@@ -0,0 +1,21 @@
+export interface ImportMap {
+    version: string;
+    generated: number;
+    imports: {
+        [specifier: string]: string;
+    };
+}
+/**
+ * Scan workspace and generate import map
+ * This pre-resolves all known packages to eliminate runtime scanning
+ */
+export declare function generateImportMap(root: string, workspaceRoot: string | null): Promise<ImportMap>;
+/**
+ * Save import map to file
+ */
+export declare function saveImportMap(importMap: ImportMap, outputPath: string): Promise<void>;
+/**
+ * Load import map from file
+ */
+export declare function loadImportMap(filePath: string): Promise<ImportMap | null>;
+//# sourceMappingURL=generate-import-map.d.ts.map

package/dist/utils/generate-import-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-import-map.d.ts","sourceRoot":"","sources":["../../src/utils/generate-import-map.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE;QACP,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;KAC7B,CAAC;CACH;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,CAAC,SAAS,CAAC,CAkGpB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAO3B"}

package/dist/utils/generate-import-map.js

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Generate pre-resolved import maps at build time
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { ModuleResolver } from "../resolver.js";
+import chalk from "chalk";
+import { getPackageRegistry } from "./package-registry.js";
+import { findSwissLibMonorepo } from "./package-finder.js";
+/**
+ * Scan workspace and generate import map
+ * This pre-resolves all known packages to eliminate runtime scanning
+ */
+export async function generateImportMap(root, workspaceRoot) {
+    const resolver = new ModuleResolver(root);
+    const importMap = {
+        version: "1.0",
+        generated: Date.now(),
+        imports: {},
+    };
+    console.log(chalk.blue("[ImportMap] Using dynamic package registry..."));
+    // Use dynamic package registry instead of manual scanning
+    const registry = getPackageRegistry();
+    const scanRoot = workspaceRoot || root;
+    if (!scanRoot) {
+        console.warn(chalk.yellow("[ImportMap] No workspace root or app root provided, cannot scan packages"));
+        return importMap;
+    }
+    // Add swiss-lib monorepo if it exists
+    const additionalRoots = [];
+    const swissLib = await findSwissLibMonorepo(root);
+    if (swissLib) {
+        try {
+            const swissPackageJson = path.join(swissLib, "package.json");
+            await fs.access(swissPackageJson);
+            additionalRoots.push(swissLib);
+            console.log(chalk.blue("[ImportMap] Including swiss-lib monorepo..."));
+        }
+        catch {
+            // swiss-lib monorepo not accessible, skip
+        }
+    }
+    // Scan workspace using registry
+    try {
+        await registry.scanWorkspace(scanRoot, additionalRoots);
+    }
+    catch (error) {
+        console.error(chalk.red(`[ImportMap] Error scanning workspace: ${error.message}`));
+        return importMap;
+    }
+    // Get all discovered packages
+    const packages = registry.getAllPackages().map(pkg => ({
+        name: pkg.name,
+        path: pkg.path,
+    }));
+    console.log(chalk.blue(`[ImportMap] Resolving ${packages.length} packages...`));
+    // Resolve each package
+    let resolved = 0;
+    for (const pkg of packages) {
+        try {
+            // Resolve main export
+            const resolvedPath = await resolver.resolve(pkg.name, "");
+            if (resolvedPath && !resolvedPath.startsWith("http")) {
+                importMap.imports[pkg.name] = resolvedPath;
+                resolved++;
+            }
+            // Also resolve common subpaths (components, tokens, etc.)
+            const commonSubpaths = [
+                "/components",
+                "/tokens",
+                "/context",
+                "/shell",
+                "/jsx-runtime",
+                "/jsx-dev-runtime",
+            ];
+            for (const subpath of commonSubpaths) {
+                try {
+                    const subpathSpecifier = `${pkg.name}${subpath}`;
+                    const subpathResolved = await resolver.resolve(subpathSpecifier, "");
+                    if (subpathResolved && !subpathResolved.startsWith("http")) {
+                        importMap.imports[subpathSpecifier] = subpathResolved;
+                        resolved++;
+                    }
+                }
+                catch {
+                    // Subpath doesn't exist, skip
+                }
+            }
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`[ImportMap] Failed to resolve ${pkg.name}:`, error));
+        }
+    }
+    console.log(chalk.green(`[ImportMap] ✅ Generated import map with ${resolved} entries`));
+    return importMap;
+}
+/**
+ * Save import map to file
+ */
+export async function saveImportMap(importMap, outputPath) {
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, JSON.stringify(importMap, null, 2), "utf-8");
+    console.log(chalk.green(`[ImportMap] ✅ Saved to ${outputPath}`));
+}
+/**
+ * Load import map from file
+ */
+export async function loadImportMap(filePath) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/package-finder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dynamically find package directories by searching up the file tree
+ * No hardcoded paths - works from any directory structure
+ */
+export interface PackageLocation {
+    path: string;
+    type: 'swiss-lib' | 'workspace' | 'node_modules';
+}
+/**
+ * Find swiss-lib monorepo by searching for swiss-lib/package.json or swiss-lib/packages/core
+ */
+export declare function findSwissLibMonorepo(startPath: string): Promise<string | null>;
+/**
+ * Find a specific package by name, searching in:
+ * 1. node_modules (local and workspace)
+ * 2. swiss-lib/packages (if found)
+ * 3. workspace packages (lib/, packages/, modules/)
+ */
+export declare function findPackage(packageName: string, startPath: string, workspaceRoot?: string | null): Promise<PackageLocation | null>;
+/**
+ * Find all possible workspace roots by searching up the tree
+ */
+export declare function findWorkspaceRoots(startPath: string): Promise<string[]>;
+//# sourceMappingURL=package-finder.d.ts.map

package/dist/utils/package-finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-finder.d.ts","sourceRoot":"","sources":["../../src/utils/package-finder.ts"],"names":[],"mappings":"AASA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,cAAc,CAAC;CAClD;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA0DpF;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,GAC5B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAoDjC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA2B7E"}

package/dist/utils/package-finder.js

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import path from "node:path";
+/**
+ * Find swiss-lib monorepo by searching for swiss-lib/package.json or swiss-lib/packages/core
+ */
+export async function findSwissLibMonorepo(startPath) {
+    let current = startPath;
+    for (let i = 0; i < 20; i++) { // Search up to 20 levels
+        // Check for swiss-lib directory with packages/core
+        const swissLibPath = path.join(current, "swiss-lib");
+        const swissLibPackageJson = path.join(swissLibPath, "package.json");
+        const corePackage = path.join(swissLibPath, "packages", "core", "package.json");
+        try {
+            // Check if swiss-lib exists and has core package
+            if (await fileExists(swissLibPackageJson) || await fileExists(corePackage)) {
+                console.log(`[package-finder] Found swiss-lib at: ${swissLibPath}`);
+                return swissLibPath;
+            }
+        }
+        catch {
+            // Continue searching
+        }
+        // Also check for legacy SWISS directory
+        const swissPath = path.join(current, "SWISS");
+        const swissPackageJson = path.join(swissPath, "package.json");
+        const swissCorePackage = path.join(swissPath, "packages", "core", "package.json");
+        try {
+            if (await fileExists(swissPackageJson) || await fileExists(swissCorePackage)) {
+                console.log(`[package-finder] Found legacy SWISS at: ${swissPath}`);
+                return swissPath;
+            }
+        }
+        catch {
+            // Continue searching
+        }
+        // Scan immediate subdirectories of `current` for a swiss-lib/ child
+        try {
+            const entries = await fs.readdir(current, { withFileTypes: true });
+            const subdirs = entries.filter((e) => e.name !== "node_modules" && (e.isDirectory() || e.isSymbolicLink()));
+            for (const entry of subdirs) {
+                const sub = path.join(current, entry.name);
+                const subSwissLib = path.join(sub, "swiss-lib");
+                const subPkgJson = path.join(subSwissLib, "package.json");
+                const subCorePkgJson = path.join(subSwissLib, "packages", "core", "package.json");
+                if (await fileExists(subPkgJson) || await fileExists(subCorePkgJson)) {
+                    console.log(`[package-finder] Found swiss-lib via subdir scan at: ${subSwissLib}`);
+                    return subSwissLib;
+                }
+            }
+        }
+        catch {
+            // Skip on permission errors
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+/**
+ * Find a specific package by name, searching in:
+ * 1. node_modules (local and workspace)
+ * 2. swiss-lib/packages (if found)
+ * 3. workspace packages (lib/, packages/, modules/)
+ */
+export async function findPackage(packageName, startPath, workspaceRoot) {
+    // 1. Check local node_modules
+    const localNodeModules = path.join(startPath, "node_modules", packageName);
+    if (await fileExists(path.join(localNodeModules, "package.json"))) {
+        return { path: localNodeModules, type: 'node_modules' };
+    }
+    // 2. Check workspace root node_modules
+    if (workspaceRoot) {
+        const workspaceNodeModules = path.join(workspaceRoot, "node_modules", packageName);
+        if (await fileExists(path.join(workspaceNodeModules, "package.json"))) {
+            return { path: workspaceNodeModules, type: 'node_modules' };
+        }
+    }
+    // 3. Check swiss-lib monorepo (for @kibologic/* packages)
+    if (packageName.startsWith("@kibologic/")) {
+        const swissLib = await findSwissLibMonorepo(startPath);
+        if (swissLib) {
+            const packageDir = packageName.replace("@kibologic/", "");
+            const swissPackage = path.join(swissLib, "packages", packageDir);
+            if (await fileExists(path.join(swissPackage, "package.json"))) {
+                return { path: swissPackage, type: 'swiss-lib' };
+            }
+        }
+    }
+    // 4. Check workspace packages (lib/, packages/, modules/)
+    if (workspaceRoot) {
+        const packageDirs = ["lib", "packages", "modules", "libraries", "apps"];
+        for (const dir of packageDirs) {
+            const searchDir = path.join(workspaceRoot, dir);
+            if (!(await fileExists(searchDir)))
+                continue;
+            // Try scoped package name
+            if (packageName.startsWith("@")) {
+                const unscoped = packageName.split("/")[1];
+                const packagePath = path.join(searchDir, unscoped);
+                if (await fileExists(path.join(packagePath, "package.json"))) {
+                    return { path: packagePath, type: 'workspace' };
+                }
+            }
+            // Try full package name
+            const packagePath = path.join(searchDir, packageName);
+            if (await fileExists(path.join(packagePath, "package.json"))) {
+                return { path: packagePath, type: 'workspace' };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Find all possible workspace roots by searching up the tree
+ */
+export async function findWorkspaceRoots(startPath) {
+    const roots = [];
+    let current = startPath;
+    for (let i = 0; i < 20; i++) {
+        const workspaceFile = path.join(current, "pnpm-workspace.yaml");
+        const packageJson = path.join(current, "package.json");
+        try {
+            if (await fileExists(workspaceFile)) {
+                roots.push(current);
+            }
+            else if (await fileExists(packageJson)) {
+                const pkg = JSON.parse(await fs.readFile(packageJson, "utf-8"));
+                if (pkg?.workspaces) {
+                    roots.push(current);
+                }
+            }
+        }
+        catch {
+            // Continue
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return roots;
+}
+/**
+ * Check if a file exists
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/package-registry.d.ts

@@ -0,0 +1,36 @@
+export interface PackageInfo {
+    name: string;
+    path: string;
+    packageJson: any;
+}
+export declare class PackageRegistry {
+    private packages;
+    private scanned;
+    private scanRoots;
+    /**
+     * Scan workspace for all packages
+     */
+    scanWorkspace(workspaceRoot: string, additionalRoots?: string[]): Promise<void>;
+    /**
+     * Recursively scan directory for package.json files
+     */
+    private scanDirectory;
+    /**
+     * Find package by name
+     */
+    findPackage(packageName: string): PackageInfo | null;
+    /**
+     * Get all packages
+     */
+    getAllPackages(): PackageInfo[];
+    /**
+     * Clear cache and rescan
+     */
+    rescan(): Promise<void>;
+    /**
+     * Get package count
+     */
+    getPackageCount(): number;
+}
+export declare function getPackageRegistry(): PackageRegistry;
+//# sourceMappingURL=package-registry.d.ts.map

package/dist/utils/package-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-registry.d.ts","sourceRoot":"","sources":["../../src/utils/package-registry.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,GAAG,CAAC;CAClB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAgB;IAEjC;;OAEG;IACG,aAAa,CACjB,aAAa,EAAE,MAAM,EACrB,eAAe,GAAE,MAAM,EAAO,GAC7B,OAAO,CAAC,IAAI,CAAC;IAwChB;;OAEG;YACW,aAAa;IAmF3B;;OAEG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAIpD;;OAEG;IACH,cAAc,IAAI,WAAW,EAAE;IAI/B;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAW7B;;OAEG;IACH,eAAe,IAAI,MAAM;CAG1B;AAKD,wBAAgB,kBAAkB,IAAI,eAAe,CAKpD"}