@mg21st/dev-assist 1.0.0

package/dist/generators/docsGenerator.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocsGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const astParser_1 = require("../parser/astParser");
+class DocsGenerator {
+    constructor() {
+        this.parser = new astParser_1.AstParser();
+    }
+    async generate(options) {
+        const spinner = (0, ora_1.default)('Scanning source files for API routes...').start();
+        const parsedFiles = await this.parser.parseDirectory(options.sourceDir);
+        const endpoints = [];
+        for (const parsedFile of parsedFiles) {
+            for (const route of parsedFile.routes) {
+                endpoints.push(this.buildEndpoint(route));
+            }
+        }
+        spinner.text = `Generating documentation for ${endpoints.length} endpoints...`;
+        const doc = {
+            title: options.title || 'API Documentation',
+            version: '1.0.0',
+            baseUrl: options.baseUrl || 'http://localhost:3000',
+            endpoints,
+            generatedAt: new Date().toISOString(),
+        };
+        fs.mkdirSync(options.outputDir, { recursive: true });
+        fs.writeFileSync(path.join(options.outputDir, 'api-docs.json'), JSON.stringify(doc, null, 2));
+        fs.writeFileSync(path.join(options.outputDir, 'api-docs.md'), this.generateMarkdown(doc));
+        fs.writeFileSync(path.join(options.outputDir, 'openapi.json'), JSON.stringify(this.generateOpenApiSpec(doc), null, 2));
+        spinner.succeed(chalk_1.default.green(`Generated API docs for ${endpoints.length} endpoints`));
+        return doc;
+    }
+    buildEndpoint(route) {
+        const pathParams = route.params.map(p => ({
+            name: p,
+            type: 'string',
+            required: true,
+        }));
+        const exampleRequest = {};
+        const exampleResponse = {
+            success: true,
+            data: {},
+            message: 'Operation completed successfully',
+        };
+        if (['POST', 'PUT', 'PATCH'].includes(route.method)) {
+            exampleRequest.body = { key: 'value' };
+        }
+        return {
+            method: route.method,
+            path: route.path,
+            params: pathParams,
+            queryParams: [],
+            description: `${route.method} ${route.path}`,
+            exampleRequest,
+            exampleResponse,
+        };
+    }
+    generateMarkdown(doc) {
+        const lines = [
+            `# ${doc.title}`,
+            '',
+            `**Version:** ${doc.version}`,
+            `**Base URL:** ${doc.baseUrl}`,
+            `**Generated:** ${doc.generatedAt}`,
+            '',
+            '## Endpoints',
+            '',
+        ];
+        for (const endpoint of doc.endpoints) {
+            lines.push(`### ${endpoint.method} \`${endpoint.path}\``);
+            lines.push('');
+            if (endpoint.description) {
+                lines.push(endpoint.description);
+                lines.push('');
+            }
+            if (endpoint.params.length > 0) {
+                lines.push('**Path Parameters:**');
+                lines.push('');
+                lines.push('| Name | Type | Required |');
+                lines.push('|------|------|----------|');
+                for (const p of endpoint.params) {
+                    lines.push(`| ${p.name} | ${p.type} | ${p.required ? 'Yes' : 'No'} |`);
+                }
+                lines.push('');
+            }
+            if (endpoint.exampleRequest && Object.keys(endpoint.exampleRequest).length > 0) {
+                lines.push('**Example Request:**');
+                lines.push('```json');
+                lines.push(JSON.stringify(endpoint.exampleRequest, null, 2));
+                lines.push('```');
+                lines.push('');
+            }
+            if (endpoint.exampleResponse) {
+                lines.push('**Example Response:**');
+                lines.push('```json');
+                lines.push(JSON.stringify(endpoint.exampleResponse, null, 2));
+                lines.push('```');
+                lines.push('');
+            }
+            lines.push('---');
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    generateOpenApiSpec(doc) {
+        const paths = {};
+        for (const endpoint of doc.endpoints) {
+            const openApiPath = endpoint.path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+            if (!paths[openApiPath]) {
+                paths[openApiPath] = {};
+            }
+            const pathItem = paths[openApiPath];
+            const method = endpoint.method.toLowerCase();
+            pathItem[method] = {
+                summary: endpoint.description,
+                parameters: endpoint.params.map(p => ({
+                    name: p.name,
+                    in: 'path',
+                    required: p.required,
+                    schema: { type: p.type },
+                })),
+                responses: {
+                    '200': {
+                        description: 'Success',
+                        content: {
+                            'application/json': {
+                                example: endpoint.exampleResponse,
+                            },
+                        },
+                    },
+                },
+            };
+        }
+        return {
+            openapi: '3.0.0',
+            info: {
+                title: doc.title,
+                version: doc.version,
+            },
+            servers: [{ url: doc.baseUrl }],
+            paths,
+        };
+    }
+}
+exports.DocsGenerator = DocsGenerator;
+//# sourceMappingURL=docsGenerator.js.map

package/dist/generators/testGenerator.d.ts

@@ -0,0 +1,12 @@
+import { GeneratedTest } from '../shared/types';
+export declare class TestGenerator {
+    private parser;
+    constructor();
+    generate(options: {
+        sourceDir: string;
+        outputDir: string;
+        framework: 'jest' | 'vitest';
+    }): Promise<GeneratedTest[]>;
+    private generateTestContent;
+}
+//# sourceMappingURL=testGenerator.d.ts.map

package/dist/generators/testGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testGenerator.d.ts","sourceRoot":"","sources":["../../src/generators/testGenerator.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAA+B,MAAM,iBAAiB,CAAC;AAE7E,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAY;;IAMpB,QAAQ,CAAC,OAAO,EAAE;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC;KAC9B,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAsC5B,OAAO,CAAC,mBAAmB;CAqG5B"}

package/dist/generators/testGenerator.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const astParser_1 = require("../parser/astParser");
+class TestGenerator {
+    constructor() {
+        this.parser = new astParser_1.AstParser();
+    }
+    async generate(options) {
+        const spinner = (0, ora_1.default)('Scanning source files...').start();
+        const parsedFiles = await this.parser.parseDirectory(options.sourceDir);
+        spinner.text = `Generating tests for ${parsedFiles.length} files...`;
+        const generated = [];
+        for (const parsedFile of parsedFiles) {
+            if (parsedFile.functions.length === 0 && parsedFile.routes.length === 0)
+                continue;
+            const testContent = this.generateTestContent(parsedFile.filePath, {
+                functions: parsedFile.functions,
+                routes: parsedFile.routes,
+                framework: options.framework,
+                sourceDir: options.sourceDir,
+                outputDir: options.outputDir,
+            });
+            const relativePath = path.relative(options.sourceDir, parsedFile.filePath);
+            const testFileName = relativePath.replace(/\.(js|ts|jsx|tsx)$/, `.test.${parsedFile.filePath.endsWith('.ts') || parsedFile.filePath.endsWith('.tsx') ? 'ts' : 'js'}`);
+            const outputPath = path.join(options.outputDir, testFileName);
+            fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+            fs.writeFileSync(outputPath, testContent);
+            generated.push({
+                filePath: outputPath,
+                sourceFile: parsedFile.filePath,
+                framework: options.framework,
+                content: testContent,
+            });
+        }
+        spinner.succeed(chalk_1.default.green(`Generated ${generated.length} test files`));
+        return generated;
+    }
+    generateTestContent(filePath, options) {
+        const { functions, routes, framework } = options;
+        const relativeImport = path.relative(path.dirname(path.join(options.outputDir, path.relative(options.sourceDir, filePath))), filePath).replace(/\.(ts|tsx)$/, '');
+        const lines = [];
+        if (framework === 'vitest') {
+            lines.push(`import { describe, it, expect, vi, beforeEach } from 'vitest';`);
+        }
+        else {
+            lines.push(`import { describe, it, expect, jest, beforeEach } from '@jest/globals';`);
+        }
+        lines.push(`import * as module from '${relativeImport.startsWith('.') ? relativeImport : './' + relativeImport}';`);
+        lines.push('');
+        for (const fn of functions) {
+            lines.push(`describe('${fn.name}', () => {`);
+            lines.push(`  it('should be defined', () => {`);
+            lines.push(`    expect(module.${fn.name}).toBeDefined();`);
+            lines.push(`  });`);
+            lines.push('');
+            if (fn.isAsync) {
+                lines.push(`  it('should return a promise', async () => {`);
+                const mockArgs = fn.params.map(() => 'undefined').join(', ');
+                lines.push(`    const result = module.${fn.name}(${mockArgs});`);
+                lines.push(`    expect(result).toBeInstanceOf(Promise);`);
+                lines.push(`  });`);
+            }
+            else {
+                lines.push(`  it('should execute without throwing', () => {`);
+                const mockArgs = generateMockArgs(fn.params);
+                lines.push(`    expect(() => module.${fn.name}(${mockArgs})).not.toThrow();`);
+                lines.push(`  });`);
+            }
+            lines.push('');
+            lines.push(`  it('should handle edge case: null/undefined inputs', ${fn.isAsync ? 'async ' : ''}() => {`);
+            lines.push(`    // Edge case: test with null/undefined inputs`);
+            const nullArgs = fn.params.map(() => 'null').join(', ');
+            if (fn.isAsync) {
+                lines.push(`    try {`);
+                lines.push(`      await module.${fn.name}(${nullArgs});`);
+                lines.push(`    } catch (e) {`);
+                lines.push(`      expect(e).toBeDefined();`);
+                lines.push(`    }`);
+            }
+            else {
+                lines.push(`    try {`);
+                lines.push(`      module.${fn.name}(${nullArgs});`);
+                lines.push(`    } catch (e) {`);
+                lines.push(`      expect(e).toBeDefined();`);
+                lines.push(`    }`);
+            }
+            lines.push(`  });`);
+            lines.push(`});`);
+            lines.push('');
+        }
+        if (routes.length > 0) {
+            lines.push(`// Express Route Tests`);
+            lines.push(`describe('Express Routes', () => {`);
+            for (const route of routes) {
+                lines.push(`  describe('${route.method} ${route.path}', () => {`);
+                lines.push(`    it('should handle request correctly', () => {`);
+                lines.push(`      const mockReq = {`);
+                lines.push(`        params: { ${route.params.map(p => `${p}: 'test'`).join(', ')} },`);
+                lines.push(`        query: {},`);
+                lines.push(`        body: {},`);
+                lines.push(`        headers: {},`);
+                lines.push(`      };`);
+                lines.push(`      const mockRes = {`);
+                lines.push(`        status: ${framework === 'jest' ? 'jest' : 'vi'}.fn().mockReturnThis(),`);
+                lines.push(`        json: ${framework === 'jest' ? 'jest' : 'vi'}.fn().mockReturnThis(),`);
+                lines.push(`        send: ${framework === 'jest' ? 'jest' : 'vi'}.fn().mockReturnThis(),`);
+                lines.push(`      };`);
+                lines.push(`      expect(mockReq).toBeDefined();`);
+                lines.push(`      expect(mockRes).toBeDefined();`);
+                lines.push(`    });`);
+                lines.push(`  });`);
+                lines.push('');
+            }
+            lines.push(`});`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.TestGenerator = TestGenerator;
+function generateMockArgs(params) {
+    return params.map(param => {
+        if (param.includes('...'))
+            return '[]';
+        const lower = param.toLowerCase();
+        if (lower.includes('id'))
+            return "'test-id'";
+        if (lower.includes('name'))
+            return "'test-name'";
+        if (lower.includes('email'))
+            return "'test@example.com'";
+        if (lower.includes('num') || lower.includes('count') || lower.includes('age'))
+            return '0';
+        if (lower.includes('flag') || lower.includes('bool') || lower.includes('is') || lower.includes('has'))
+            return 'false';
+        if (lower.includes('arr') || lower.includes('list') || lower.includes('items'))
+            return '[]';
+        if (lower.includes('obj') || lower.includes('data') || lower.includes('config'))
+            return '{}';
+        if (lower.includes('fn') || lower.includes('callback') || lower.includes('cb'))
+            return '() => {}';
+        return "''";
+    }).join(', ');
+}
+//# sourceMappingURL=testGenerator.js.map

package/dist/parser/astParser.d.ts

@@ -0,0 +1,7 @@
+import { ParsedFile } from '../shared/types';
+export declare class AstParser {
+    parseFile(filePath: string): Promise<ParsedFile>;
+    parseDirectory(dirPath: string): Promise<ParsedFile[]>;
+    private getFiles;
+}
+//# sourceMappingURL=astParser.d.ts.map

package/dist/parser/astParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astParser.d.ts","sourceRoot":"","sources":["../../src/parser/astParser.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAA+B,MAAM,iBAAiB,CAAC;AAE1E,qBAAa,SAAS;IACd,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAuFhD,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAgB5D,OAAO,CAAC,QAAQ;CAwBjB"}

package/dist/parser/astParser.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstParser = void 0;
+const parser = __importStar(require("@babel/parser"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AstParser {
+    async parseFile(filePath) {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const ext = path.extname(filePath);
+        const plugins = ['jsx'];
+        if (ext === '.ts' || ext === '.tsx') {
+            plugins.push('typescript');
+        }
+        let ast;
+        try {
+            ast = parser.parse(content, {
+                sourceType: 'module',
+                plugins,
+                errorRecovery: true,
+            });
+        }
+        catch {
+            return { filePath, functions: [], routes: [], imports: [] };
+        }
+        const functions = [];
+        const routes = [];
+        const imports = [];
+        (0, traverse_1.default)(ast, {
+            ImportDeclaration(nodePath) {
+                imports.push(nodePath.node.source.value);
+            },
+            ExportNamedDeclaration(nodePath) {
+                const declaration = nodePath.node.declaration;
+                if (!declaration)
+                    return;
+                if (t.isFunctionDeclaration(declaration) && declaration.id) {
+                    functions.push(extractFunction(declaration));
+                }
+                else if (t.isVariableDeclaration(declaration)) {
+                    declaration.declarations.forEach(decl => {
+                        if (t.isVariableDeclarator(decl) &&
+                            t.isIdentifier(decl.id) &&
+                            (t.isArrowFunctionExpression(decl.init) || t.isFunctionExpression(decl.init))) {
+                            functions.push(extractVariableFunction(decl.id.name, decl.init));
+                        }
+                    });
+                }
+            },
+            ExportDefaultDeclaration(nodePath) {
+                const declaration = nodePath.node.declaration;
+                if (t.isFunctionDeclaration(declaration)) {
+                    const fn = extractFunction(declaration);
+                    fn.name = fn.name || 'default';
+                    functions.push(fn);
+                }
+            },
+            CallExpression(nodePath) {
+                const node = nodePath.node;
+                if (t.isMemberExpression(node.callee) &&
+                    t.isIdentifier(node.callee.property)) {
+                    const method = node.callee.property.name.toUpperCase();
+                    const httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+                    if (httpMethods.includes(method) && node.arguments.length >= 2) {
+                        const firstArg = node.arguments[0];
+                        if (t.isStringLiteral(firstArg)) {
+                            const routePath = firstArg.value;
+                            const params = extractPathParams(routePath);
+                            routes.push({
+                                method,
+                                path: routePath,
+                                handler: `handler_${method.toLowerCase()}_${routePath.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                                params,
+                                middleware: [],
+                            });
+                        }
+                    }
+                }
+            },
+        });
+        return { filePath, functions, routes, imports };
+    }
+    async parseDirectory(dirPath) {
+        const results = [];
+        const files = this.getFiles(dirPath);
+        for (const file of files) {
+            try {
+                const parsed = await this.parseFile(file);
+                results.push(parsed);
+            }
+            catch {
+                // Skip unparseable files
+            }
+        }
+        return results;
+    }
+    getFiles(dirPath) {
+        const files = [];
+        if (!fs.existsSync(dirPath))
+            return files;
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                if (!['node_modules', '.git', 'dist', 'build', 'coverage'].includes(entry.name)) {
+                    files.push(...this.getFiles(fullPath));
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (['.js', '.ts', '.jsx', '.tsx'].includes(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        return files;
+    }
+}
+exports.AstParser = AstParser;
+function extractFunction(node) {
+    return {
+        name: node.id?.name || 'anonymous',
+        params: node.params.map(p => {
+            if (t.isIdentifier(p))
+                return p.name;
+            if (t.isAssignmentPattern(p) && t.isIdentifier(p.left))
+                return p.left.name;
+            if (t.isRestElement(p) && t.isIdentifier(p.argument))
+                return `...${p.argument.name}`;
+            return 'param';
+        }),
+        isAsync: node.async,
+        isExported: true,
+    };
+}
+function extractVariableFunction(name, node) {
+    return {
+        name,
+        params: node.params.map(p => {
+            if (t.isIdentifier(p))
+                return p.name;
+            if (t.isAssignmentPattern(p) && t.isIdentifier(p.left))
+                return p.left.name;
+            if (t.isRestElement(p) && t.isIdentifier(p.argument))
+                return `...${p.argument.name}`;
+            return 'param';
+        }),
+        isAsync: node.async,
+        isExported: true,
+    };
+}
+function extractPathParams(routePath) {
+    const matches = routePath.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
+    return matches ? matches.map(m => m.slice(1)) : [];
+}
+//# sourceMappingURL=astParser.js.map

package/dist/server/index.d.ts

@@ -0,0 +1,5 @@
+export declare function startServer(options: {
+    port: number;
+    openBrowser: boolean;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAeA,wBAAsB,WAAW,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8NhG"}