@skmtc/core 0.0.792 → 0.0.794

package/esm/helpers/collateExamples.js

@@ -1,6 +1,151 @@
 import "../_dnt.polyfills.js";
 import { match } from 'ts-pattern';
 import { isEmpty } from './isEmpty.js';
+/**
+ * Recursively collates and builds example values from OpenAPI schemas.
+ *
+ * This function traverses OpenAPI schema structures and generates comprehensive
+ * example values based on the schema definitions and any explicit examples provided.
+ * It handles complex nested structures including objects, arrays, unions, and
+ * references while preventing infinite recursion through depth limiting.
+ *
+ * The function prioritizes explicit examples when available and falls back to
+ * generating examples from nested schemas. It's particularly useful for creating
+ * realistic test data, API documentation examples, and mock responses.
+ *
+ * @param args - Configuration for example collation
+ * @param args.objectSchema - The schema to extract examples from
+ * @param args.depth - Current recursion depth (prevents infinite loops)
+ * @returns Collated example value matching the schema structure, or undefined if no examples
+ *
+ * @throws {Error} When recursion depth exceeds 15 levels (prevents stack overflow)
+ *
+ * @example Basic schema examples
+ * ```typescript
+ * import { collateExamples } from '@skmtc/core';
+ *
+ * // String schema with example
+ * const stringSchema = new OasString({ example: 'john.doe@example.com' });
+ * const example = collateExamples({ objectSchema: stringSchema, depth: 0 });
+ * console.log(example); // 'john.doe@example.com'
+ *
+ * // Number schema with example
+ * const numberSchema = new OasNumber({ example: 42 });
+ * const numExample = collateExamples({ objectSchema: numberSchema, depth: 0 });
+ * console.log(numExample); // 42
+ * ```
+ *
+ * @example Object schema examples
+ * ```typescript
+ * // Object schema with nested properties
+ * const userSchema = new OasObject({
+ *   properties: {
+ *     id: new OasInteger({ example: 123 }),
+ *     name: new OasString({ example: 'John Doe' }),
+ *     email: new OasString({ example: 'john@example.com' }),
+ *     age: new OasInteger({ example: 30 })
+ *   }
+ * });
+ *
+ * const userExample = collateExamples({ objectSchema: userSchema, depth: 0 });
+ * console.log(userExample);
+ * // {
+ * //   id: 123,
+ * //   name: 'John Doe',
+ * //   email: 'john@example.com',
+ * //   age: 30
+ * // }
+ * ```
+ *
+ * @example Array schema examples
+ * ```typescript
+ * // Array of objects
+ * const usersArraySchema = new OasArray({
+ *   items: new OasObject({
+ *     properties: {
+ *       id: new OasInteger({ example: 1 }),
+ *       name: new OasString({ example: 'Jane Smith' })
+ *     }
+ *   })
+ * });
+ *
+ * const arrayExample = collateExamples({ objectSchema: usersArraySchema, depth: 0 });
+ * console.log(arrayExample);
+ * // [
+ * //   {
+ * //     id: 1,
+ * //     name: 'Jane Smith'
+ * //   }
+ * // ]
+ * ```
+ *
+ * @example Union schema examples
+ * ```typescript
+ * // Union of string and number
+ * const unionSchema = new OasUnion({
+ *   members: [
+ *     new OasString({ example: 'text-value' }),
+ *     new OasNumber({ example: 99 })
+ *   ]
+ * });
+ *
+ * const unionExample = collateExamples({ objectSchema: unionSchema, depth: 0 });
+ * console.log(unionExample); // 'text-value' (first member with example)
+ * ```
+ *
+ * @example Reference resolution
+ * ```typescript
+ * // Schema with reference to another schema
+ * const addressRef = new OasRef({
+ *   $ref: '#/components/schemas/Address',
+ *   resolve: () => new OasObject({
+ *     properties: {
+ *       street: new OasString({ example: '123 Main St' }),
+ *       city: new OasString({ example: 'Springfield' })
+ *     }
+ *   })
+ * });
+ *
+ * const refExample = collateExamples({ objectSchema: addressRef, depth: 0 });
+ * console.log(refExample);
+ * // {
+ * //   street: '123 Main St',
+ * //   city: 'Springfield'
+ * // }
+ * ```
+ *
+ * @example Depth limiting and error handling
+ * ```typescript
+ * // Deep nesting detection
+ * try {
+ *   const deepExample = collateExamples({ objectSchema: someSchema, depth: 16 });
+ * } catch (error) {
+ *   console.error('Depth limit exceeded:', error.message); // 'Depth limit reached'
+ * }
+ *
+ * // Handling missing schemas
+ * const emptyExample = collateExamples({ objectSchema: undefined, depth: 0 });
+ * console.log(emptyExample); // undefined
+ * ```
+ *
+ * @example Using in API documentation generation
+ * ```typescript
+ * class ApiDocGenerator {
+ *   generateExampleResponse(responseSchema: OasSchema) {
+ *     const example = collateExamples({ objectSchema: responseSchema, depth: 0 });
+ *
+ *     if (example) {
+ *       return {
+ *         description: 'Example response',
+ *         value: example
+ *       };
+ *     }
+ *
+ *     return { description: 'No example available' };
+ *   }
+ * }
+ * ```
+ */
 export const collateExamples = ({ objectSchema, depth }) => {
     if (!objectSchema) {
         return undefined;

package/esm/helpers/formatNumber.d.ts

@@ -1,3 +1,98 @@
+/**
+ * Formats a number using locale-specific formatting without decimal places.
+ *
+ * This utility function formats numbers according to locale conventions,
+ * adding thousand separators and other locale-specific number formatting
+ * while ensuring the output contains no fractional digits. It's useful
+ * for displaying counts, statistics, or other whole numbers in a
+ * human-readable format.
+ *
+ * @param value - The number to format
+ * @param locales - The locale(s) to use for formatting (defaults to 'en-US')
+ * @returns The formatted number as a string with locale-appropriate thousand separators
+ *
+ * @example Basic formatting with default locale (en-US)
+ * ```typescript
+ * import { formatNumber } from '@skmtc/core';
+ *
+ * console.log(formatNumber(1234));     // '1,234'
+ * console.log(formatNumber(1234567));  // '1,234,567'
+ * console.log(formatNumber(42));       // '42'
+ * console.log(formatNumber(0));        // '0'
+ * ```
+ *
+ * @example Formatting with different locales
+ * ```typescript
+ * const bigNumber = 1234567;
+ *
+ * console.log(formatNumber(bigNumber, 'en-US')); // '1,234,567'
+ * console.log(formatNumber(bigNumber, 'de-DE')); // '1.234.567'
+ * console.log(formatNumber(bigNumber, 'fr-FR')); // '1 234 567'
+ * console.log(formatNumber(bigNumber, 'en-IN')); // '12,34,567'
+ * ```
+ *
+ * @example Formatting decimal numbers (fractional part removed)
+ * ```typescript
+ * // The function always rounds to whole numbers
+ * console.log(formatNumber(1234.56));    // '1,235' (rounded)
+ * console.log(formatNumber(999.99));     // '1,000' (rounded)
+ * console.log(formatNumber(1000.1));     // '1,000' (rounded)
+ * console.log(formatNumber(1000.0));     // '1,000'
+ * ```
+ *
+ * @example Usage in reporting and statistics
+ * ```typescript
+ * class StatsReporter {
+ *   generateReport(stats: {
+ *     totalFiles: number;
+ *     linesGenerated: number;
+ *     errors: number;
+ *   }) {
+ *     return `
+ * Generation Report:
+ * - Files generated: ${formatNumber(stats.totalFiles)}
+ * - Lines of code: ${formatNumber(stats.linesGenerated)}
+ * - Errors encountered: ${formatNumber(stats.errors)}
+ *     `.trim();
+ *   }
+ * }
+ *
+ * const reporter = new StatsReporter();
+ * const report = reporter.generateReport({
+ *   totalFiles: 1234,
+ *   linesGenerated: 567890,
+ *   errors: 5
+ * });
+ *
+ * console.log(report);
+ * // Generation Report:
+ * // - Files generated: 1,234
+ * // - Lines of code: 567,890
+ * // - Errors encountered: 5
+ * ```
+ *
+ * @example International number formatting
+ * ```typescript
+ * const count = 50000;
+ *
+ * // Different regions format numbers differently
+ * const formats = [
+ *   { locale: 'en-US', label: 'US English' },
+ *   { locale: 'de-DE', label: 'German' },
+ *   { locale: 'fr-FR', label: 'French' },
+ *   { locale: 'ja-JP', label: 'Japanese' }
+ * ];
+ *
+ * formats.forEach(({ locale, label }) => {
+ *   console.log(`${label}: ${formatNumber(count, locale)}`);
+ * });
+ *
+ * // US English: 50,000
+ * // German: 50.000
+ * // French: 50 000
+ * // Japanese: 50,000
+ * ```
+ */
 import "../_dnt.polyfills.js";
 export declare const formatNumber: (value: number, locales?: Intl.LocalesArgument) => string;
 //# sourceMappingURL=formatNumber.d.ts.map

package/esm/helpers/formatNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatNumber.d.ts","sourceRoot":"","sources":["../../src/helpers/formatNumber.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,UAAS,IAAI,CAAC,eAAyB,KAAG,MAKrF,CAAA"}
+{"version":3,"file":"formatNumber.d.ts","sourceRoot":"","sources":["../../src/helpers/formatNumber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8FG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,UAAS,IAAI,CAAC,eAAyB,KAAG,MAKrF,CAAA"}

package/esm/helpers/formatNumber.js

@@ -1,3 +1,98 @@
+/**
+ * Formats a number using locale-specific formatting without decimal places.
+ *
+ * This utility function formats numbers according to locale conventions,
+ * adding thousand separators and other locale-specific number formatting
+ * while ensuring the output contains no fractional digits. It's useful
+ * for displaying counts, statistics, or other whole numbers in a
+ * human-readable format.
+ *
+ * @param value - The number to format
+ * @param locales - The locale(s) to use for formatting (defaults to 'en-US')
+ * @returns The formatted number as a string with locale-appropriate thousand separators
+ *
+ * @example Basic formatting with default locale (en-US)
+ * ```typescript
+ * import { formatNumber } from '@skmtc/core';
+ *
+ * console.log(formatNumber(1234));     // '1,234'
+ * console.log(formatNumber(1234567));  // '1,234,567'
+ * console.log(formatNumber(42));       // '42'
+ * console.log(formatNumber(0));        // '0'
+ * ```
+ *
+ * @example Formatting with different locales
+ * ```typescript
+ * const bigNumber = 1234567;
+ *
+ * console.log(formatNumber(bigNumber, 'en-US')); // '1,234,567'
+ * console.log(formatNumber(bigNumber, 'de-DE')); // '1.234.567'
+ * console.log(formatNumber(bigNumber, 'fr-FR')); // '1 234 567'
+ * console.log(formatNumber(bigNumber, 'en-IN')); // '12,34,567'
+ * ```
+ *
+ * @example Formatting decimal numbers (fractional part removed)
+ * ```typescript
+ * // The function always rounds to whole numbers
+ * console.log(formatNumber(1234.56));    // '1,235' (rounded)
+ * console.log(formatNumber(999.99));     // '1,000' (rounded)
+ * console.log(formatNumber(1000.1));     // '1,000' (rounded)
+ * console.log(formatNumber(1000.0));     // '1,000'
+ * ```
+ *
+ * @example Usage in reporting and statistics
+ * ```typescript
+ * class StatsReporter {
+ *   generateReport(stats: {
+ *     totalFiles: number;
+ *     linesGenerated: number;
+ *     errors: number;
+ *   }) {
+ *     return `
+ * Generation Report:
+ * - Files generated: ${formatNumber(stats.totalFiles)}
+ * - Lines of code: ${formatNumber(stats.linesGenerated)}
+ * - Errors encountered: ${formatNumber(stats.errors)}
+ *     `.trim();
+ *   }
+ * }
+ *
+ * const reporter = new StatsReporter();
+ * const report = reporter.generateReport({
+ *   totalFiles: 1234,
+ *   linesGenerated: 567890,
+ *   errors: 5
+ * });
+ *
+ * console.log(report);
+ * // Generation Report:
+ * // - Files generated: 1,234
+ * // - Lines of code: 567,890
+ * // - Errors encountered: 5
+ * ```
+ *
+ * @example International number formatting
+ * ```typescript
+ * const count = 50000;
+ *
+ * // Different regions format numbers differently
+ * const formats = [
+ *   { locale: 'en-US', label: 'US English' },
+ *   { locale: 'de-DE', label: 'German' },
+ *   { locale: 'fr-FR', label: 'French' },
+ *   { locale: 'ja-JP', label: 'Japanese' }
+ * ];
+ *
+ * formats.forEach(({ locale, label }) => {
+ *   console.log(`${label}: ${formatNumber(count, locale)}`);
+ * });
+ *
+ * // US English: 50,000
+ * // German: 50.000
+ * // French: 50 000
+ * // Japanese: 50,000
+ * ```
+ */
 import "../_dnt.polyfills.js";
 export const formatNumber = (value, locales = 'en-US') => {
     return value.toLocaleString(locales, {

package/esm/helpers/generationStats.d.ts

@@ -1,26 +1,312 @@
 import "../_dnt.polyfills.js";
 import type { ManifestContent } from '../types/Manifest.js';
 import type { ResultsItem, ResultType } from '../types/Results.js';
+/**
+ * Arguments for generating comprehensive statistics from the build manifest and artifacts.
+ */
 type GenerationStatsArgs = {
+    /** The generation manifest containing build metadata and results */
     manifest: ManifestContent;
+    /** Generated artifacts as a map of file paths to content */
     artifacts: Record<string, string>;
 };
-export declare const toGenerationStats: ({ manifest, artifacts }: GenerationStatsArgs) => {
+/**
+ * Comprehensive generation statistics extracted from build artifacts and manifest.
+ */
+export type GenerationStats = {
+    /** Total number of GPT tokens in generated content */
     tokens: number;
+    /** Total number of lines generated */
     lines: number;
+    /** Total generation time in milliseconds */
     totalTime: number;
+    /** Error paths organized as nested arrays */
     errors: string[][];
+    /** Total number of generated files */
     files: number;
 };
+/**
+ * Generates comprehensive statistics about the code generation process.
+ *
+ * This function analyzes the generation manifest and produced artifacts to create
+ * detailed statistics including token counts, lines of code, timing information,
+ * error tracking, and file counts. It's used for performance monitoring, debugging,
+ * and reporting on generation runs.
+ *
+ * The function combines multiple analysis methods to provide a complete picture
+ * of the generation process, including tokenization analysis for cost estimation,
+ * error path extraction for debugging, and timing analysis for performance optimization.
+ *
+ * @param args - Generation analysis configuration
+ * @param args.manifest - The generation manifest with metadata and results
+ * @param args.artifacts - Map of file paths to generated content
+ * @returns Comprehensive generation statistics object
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { toGenerationStats } from '@skmtc/core';
+ *
+ * const stats = toGenerationStats({
+ *   manifest: {
+ *     startAt: 1672531200000,
+ *     endAt: 1672531245000,
+ *     files: {
+ *       './models.ts': { lines: 150, characters: 4500 },
+ *       './types.ts': { lines: 80, characters: 2100 }
+ *     },
+ *     results: { }
+ *   },
+ *   artifacts: {
+ *     './models.ts': 'export interface User { id: string; name: string; }',
+ *     './types.ts': 'export type Status = "active" | "inactive";'
+ *   }
+ * });
+ *
+ * console.log(stats);
+ * // {
+ * //   tokens: 250,
+ * //   lines: 230,
+ * //   totalTime: 45000,
+ * //   errors: [],
+ * //   files: 2
+ * // }
+ * ```
+ *
+ * @example Performance monitoring
+ * ```typescript
+ * class GenerationMonitor {
+ *   analyzeGeneration(manifest: ManifestContent, artifacts: Record<string, string>) {
+ *     const stats = toGenerationStats({ manifest, artifacts });
+ *
+ *     console.log(`Generation completed in ${stats.totalTime}ms`);
+ *     console.log(`Generated ${stats.files} files with ${stats.lines} lines`);
+ *     console.log(`Token usage: ${stats.tokens} tokens`);
+ *
+ *     if (stats.errors.length > 0) {
+ *       console.warn(`Found ${stats.errors.length} errors:`);
+ *       stats.errors.forEach((errorPath, index) => {
+ *         console.warn(`  ${index + 1}. ${errorPath.join(' -> ')}`);
+ *       });
+ *     }
+ *
+ *     return stats;
+ *   }
+ * }
+ * ```
+ *
+ * @example Cost estimation
+ * ```typescript
+ * function estimateGenerationCost(stats: GenerationStats): number {
+ *   const tokensPerDollar = 1000000; // Example rate
+ *   const estimatedCost = stats.tokens / tokensPerDollar;
+ *
+ *   console.log(`Estimated cost: $${estimatedCost.toFixed(4)}`);
+ *   console.log(`Efficiency: ${stats.lines / stats.tokens} lines per token`);
+ *
+ *   return estimatedCost;
+ * }
+ * ```
+ *
+ * @example Build reporting
+ * ```typescript
+ * function generateBuildReport(stats: GenerationStats): string {
+ *   const efficiency = stats.totalTime / stats.files;
+ *   const successRate = ((stats.files - stats.errors.length) / stats.files * 100).toFixed(1);
+ *
+ *   return `
+ * Build Report:
+ * -----------
+ * Files Generated: ${stats.files}
+ * Total Lines: ${stats.lines.toLocaleString()}
+ * Token Count: ${stats.tokens.toLocaleString()}
+ * Generation Time: ${(stats.totalTime / 1000).toFixed(2)}s
+ * Average per File: ${efficiency.toFixed(0)}ms
+ * Success Rate: ${successRate}%
+ * Errors: ${stats.errors.length}
+ *   `.trim();
+ * }
+ * ```
+ */
+export declare const toGenerationStats: ({ manifest, artifacts }: GenerationStatsArgs) => GenerationStats;
+/**
+ * Calculates the total number of GPT tokens in all generated artifacts.
+ *
+ * This function uses GPT tokenization to count the total number of tokens
+ * across all generated code artifacts. This is useful for cost estimation
+ * when using token-based pricing models and for understanding the size
+ * and complexity of generated content.
+ *
+ * @param artifacts - Map of file paths to generated content strings
+ * @returns Total number of GPT tokens across all artifacts
+ *
+ * @example
+ * ```typescript
+ * const artifacts = {
+ *   './models.ts': 'export interface User { id: string; name: string; }',
+ *   './types.ts': 'export type Status = "active" | "inactive";'
+ * };
+ *
+ * const tokens = toManifestTokens(artifacts);
+ * console.log(tokens); // e.g., 24 tokens
+ * ```
+ */
 export declare const toManifestTokens: (artifacts: Record<string, string>) => number;
+/**
+ * Calculates the total number of lines across all generated files.
+ *
+ * This function sums up the line counts from the manifest's file metadata
+ * to provide the total lines of code generated. This metric is useful
+ * for understanding the scale of code generation and tracking productivity.
+ *
+ * @param manifest - The generation manifest containing file metadata
+ * @returns Total number of lines across all generated files
+ *
+ * @example
+ * ```typescript
+ * const manifest = {
+ *   files: {
+ *     './models.ts': { lines: 150, characters: 4500 },
+ *     './types.ts': { lines: 80, characters: 2100 }
+ *   },
+ *   // ... other manifest properties
+ * };
+ *
+ * const lines = toManifestLines(manifest);
+ * console.log(lines); // 230
+ * ```
+ */
 export declare const toManifestLines: (manifest: ManifestContent) => number;
+/**
+ * Calculates the total generation time from the manifest timestamps.
+ *
+ * This function computes the duration of the generation process by
+ * calculating the difference between the end and start timestamps
+ * recorded in the manifest. The result is in milliseconds.
+ *
+ * @param manifest - The generation manifest with timing information
+ * @returns Total generation time in milliseconds
+ *
+ * @example
+ * ```typescript
+ * const manifest = {
+ *   startAt: 1672531200000, // January 1, 2023 00:00:00 GMT
+ *   endAt: 1672531245000,   // January 1, 2023 00:00:45 GMT
+ *   // ... other manifest properties
+ * };
+ *
+ * const duration = toTotalTime(manifest);
+ * console.log(duration); // 45000 (45 seconds)
+ * console.log(`${duration / 1000}s`); // "45s"
+ * ```
+ */
 export declare const toTotalTime: (manifest: ManifestContent) => number;
+/**
+ * Extracts and organizes error paths from the manifest results.
+ *
+ * This function recursively traverses the results structure in the manifest
+ * to identify all error conditions and their associated file paths. Errors
+ * are returned as arrays of path segments, making it easy to understand
+ * the location and context of each error.
+ *
+ * @param results - The results object from the generation manifest
+ * @returns Array of error paths, each represented as an array of path segments
+ *
+ * @example
+ * ```typescript
+ * const results = {
+ *   'models.ts': {
+ *     'User': 'success',
+ *     'Product': 'error'
+ *   },
+ *   'types.ts': 'success'
+ * };
+ *
+ * const errors = toManifestErrors(results);
+ * console.log(errors); // [['models.ts', 'Product']]
+ *
+ * // Display errors in readable format
+ * errors.forEach(errorPath => {
+ *   console.log(`Error at: ${errorPath.join(' -> ')}`);
+ * });
+ * // Output: "Error at: models.ts -> Product"
+ * ```
+ */
 export declare const toManifestErrors: (results: ManifestContent["results"]) => string[][];
+/**
+ * Arguments for recursively checking results for error conditions.
+ */
 type CheckResultArgs = {
+    /** Current path segments being traversed */
     path: string[];
+    /** The result value to check (can be nested) */
     result: ResultsItem | (ResultsItem | null)[] | ResultType;
+    /** Array to accumulate error paths (mutated) */
     errors: string[][];
 };
+/**
+ * Recursively checks results structure for error conditions and collects error paths.
+ *
+ * This function traverses the complex nested structure of generation results,
+ * identifying error conditions at any level and recording their full path context.
+ * It handles arrays, objects, strings, and null values, building a comprehensive
+ * map of all errors that occurred during generation.
+ *
+ * The function mutates the errors array parameter, accumulating error paths
+ * as it traverses the results structure. This approach is used for performance
+ * when processing large result sets.
+ *
+ * @param args - Arguments for result checking
+ * @param args.path - Current path segments being traversed
+ * @param args.result - The result value to check for errors
+ * @param args.errors - Array to accumulate error paths (mutated by function)
+ *
+ * @example Simple error detection
+ * ```typescript
+ * const errors: string[][] = [];
+ *
+ * checkResult({
+ *   path: ['models.ts'],
+ *   result: 'error',
+ *   errors
+ * });
+ *
+ * console.log(errors); // [['models.ts']]
+ * ```
+ *
+ * @example Nested structure error detection
+ * ```typescript
+ * const errors: string[][] = [];
+ * const nestedResult = {
+ *   'User': 'success',
+ *   'Product': {
+ *     'validation': 'error',
+ *     'generation': 'success'
+ *   }
+ * };
+ *
+ * checkResult({
+ *   path: ['models.ts'],
+ *   result: nestedResult,
+ *   errors
+ * });
+ *
+ * console.log(errors); // [['models.ts', 'Product', 'validation']]
+ * ```
+ *
+ * @example Array handling
+ * ```typescript
+ * const errors: string[][] = [];
+ * const arrayResult = ['success', null, 'error', 'success'];
+ *
+ * checkResult({
+ *   path: ['batch'],
+ *   result: arrayResult,
+ *   errors
+ * });
+ *
+ * console.log(errors); // [['batch']] - for the 'error' item
+ * ```
+ */
 export declare const checkResult: ({ path, result, errors }: CheckResultArgs) => void;
 export {};
 //# sourceMappingURL=generationStats.d.ts.map

package/esm/helpers/generationStats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generationStats.d.ts","sourceRoot":"","sources":["../../src/helpers/generationStats.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAIlE,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AACD,eAAO,MAAM,iBAAiB,GAAI,yBAAyB,mBAAmB,KAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAcrK,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,MAOpE,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,UAAU,eAAe,KAAG,MAO3D,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,UAAU,eAAe,KAAG,MAIvD,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,SAAS,eAAe,CAAC,SAAS,CAAC,KAAG,MAAM,EAAE,EAQ9E,CAAA;AAED,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,MAAM,EAAE,WAAW,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,EAAE,GAAG,UAAU,CAAA;IACzD,MAAM,EAAE,MAAM,EAAE,EAAE,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,0BAA0B,eAAe,KAAG,IA0BvE,CAAA"}
+{"version":3,"file":"generationStats.d.ts","sourceRoot":"","sources":["../../src/helpers/generationStats.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAIlE;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,oEAAoE;IACpE,QAAQ,EAAE,eAAe,CAAA;IACzB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAA;IACd,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAA;IACb,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,EAAE,EAAE,CAAA;IAClB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGG;AACH,eAAO,MAAM,iBAAiB,GAAI,yBAAyB,mBAAmB,KAAG,eAchF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,MAOpE,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,eAAe,KAAG,MAO3D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,eAAe,KAAG,MAIvD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,eAAe,CAAC,SAAS,CAAC,KAAG,MAAM,EAAE,EAQ9E,CAAA;AAED;;GAEG;AACH,KAAK,eAAe,GAAG;IACrB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,gDAAgD;IAChD,MAAM,EAAE,WAAW,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,EAAE,GAAG,UAAU,CAAA;IACzD,gDAAgD;IAChD,MAAM,EAAE,MAAM,EAAE,EAAE,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,WAAW,GAAI,0BAA0B,eAAe,KAAG,IA0BvE,CAAA"}