@qodalis/cli-string 0.0.1 → 0.0.3

package/esm2022/lib/processors/cli-string-command-processor.mjs

@@ -1,26 +1,541 @@
 import { Injectable } from '@angular/core';
-import { DefaultLibraryAuthor, ObjectDescriber, } from '@qodalis/cli-core';
+import { CliForegroundColor, DefaultLibraryAuthor, } from '@qodalis/cli-core';
 import * as _ from 'lodash';
+import { LIBRARY_VERSION } from '../version';
 import * as i0 from "@angular/core";
+const lodash = _.default || _;
+/**
+ * Helper to create a simple string transform subcommand
+ */
+function stringTransform(command, description, transform, options) {
+    return {
+        command,
+        aliases: options?.aliases,
+        description,
+        allowUnlistedCommands: true,
+        valueRequired: true,
+        processCommand: async (cmd, context) => {
+            const text = (cmd.value || cmd.data || '');
+            const result = transform(text);
+            context.writer.writeln(`${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`);
+            context.process.output(result);
+        },
+        writeDescription: (context) => {
+            const { writer } = context;
+            writer.writeln(description);
+            writer.writeln();
+            writer.writeln('📋 Usage:');
+            writer.writeln(`  ${writer.wrapInColor(`string ${command} <text>`, CliForegroundColor.Cyan)}`);
+            if (options?.example) {
+                writer.writeln();
+                writer.writeln('📝 Examples:');
+                writer.writeln(`  string ${command} ${options.example.input.padEnd(20)} ${writer.wrapInColor(`# → ${options.example.output}`, CliForegroundColor.Green)}`);
+            }
+        },
+    };
+}
 export class CliStringCommandProcessor {
     constructor() {
         this.command = 'string';
-        this.description = 'String commands';
+        this.aliases = ['str'];
+        this.description = 'String manipulation commands';
         this.author = DefaultLibraryAuthor;
+        this.version = LIBRARY_VERSION;
         this.processors = [];
-        this.processors = ObjectDescriber.describe(_.default, {
-            filter: ({ args }) => {
-                const skip = args.length === 0 || args[0] !== 'string';
-                return !skip;
+        this.metadata = {
+            icon: '🔤',
+            requiredCoreVersion: '0.0.16',
+            requiredCliVersion: '1.0.37',
+        };
+        this.processors = [
+            // -- Case conversions --
+            stringTransform('upper', 'Convert to UPPERCASE', (t) => t.toUpperCase(), {
+                aliases: ['uppercase', 'toUpper'],
+                example: { input: 'hello world', output: 'HELLO WORLD' },
+            }),
+            stringTransform('lower', 'Convert to lowercase', (t) => t.toLowerCase(), {
+                aliases: ['lowercase', 'toLower'],
+                example: { input: 'HELLO WORLD', output: 'hello world' },
+            }),
+            stringTransform('capitalize', 'Capitalize the first letter', (t) => lodash.capitalize(t), {
+                aliases: ['cap'],
+                example: { input: 'hello world', output: 'Hello world' },
+            }),
+            stringTransform('camelCase', 'Convert to camelCase', (t) => lodash.camelCase(t), {
+                aliases: ['camel'],
+                example: { input: 'hello world', output: 'helloWorld' },
+            }),
+            stringTransform('kebabCase', 'Convert to kebab-case', (t) => lodash.kebabCase(t), {
+                aliases: ['kebab'],
+                example: { input: 'Hello World', output: 'hello-world' },
+            }),
+            stringTransform('snakeCase', 'Convert to snake_case', (t) => lodash.snakeCase(t), {
+                aliases: ['snake'],
+                example: { input: 'Hello World', output: 'hello_world' },
+            }),
+            stringTransform('startCase', 'Convert to Start Case', (t) => lodash.startCase(t), {
+                aliases: ['title', 'titleCase'],
+                example: { input: 'hello-world', output: 'Hello World' },
+            }),
+            // -- Trimming --
+            stringTransform('trim', 'Remove whitespace from both ends', (t) => t.trim(), {
+                example: { input: '"  hello  "', output: 'hello' },
+            }),
+            stringTransform('trimStart', 'Remove whitespace from the start', (t) => t.trimStart(), {
+                aliases: ['ltrim'],
+                example: { input: '"  hello"', output: 'hello' },
+            }),
+            stringTransform('trimEnd', 'Remove whitespace from the end', (t) => t.trimEnd(), {
+                aliases: ['rtrim'],
+                example: { input: '"hello  "', output: 'hello' },
+            }),
+            // -- Transform --
+            stringTransform('reverse', 'Reverse a string', (t) => [...t].reverse().join(''), {
+                aliases: ['rev'],
+                example: { input: 'Hello', output: 'olleH' },
+            }),
+            stringTransform('slug', 'Convert to URL-friendly slug', (t) => t.toLowerCase()
+                .normalize('NFD')
+                .replace(/[\u0300-\u036f]/g, '')
+                .replace(/[^a-z0-9]+/g, '-')
+                .replace(/^-|-$/g, ''), {
+                aliases: ['slugify'],
+                example: { input: '"Hello World!"', output: 'hello-world' },
+            }),
+            stringTransform('escape', 'Escape HTML entities', (t) => lodash.escape(t), {
+                aliases: ['escapeHtml'],
+                example: { input: '"<b>hi</b>"', output: '&lt;b&gt;hi&lt;/b&gt;' },
+            }),
+            stringTransform('unescape', 'Unescape HTML entities', (t) => lodash.unescape(t), {
+                aliases: ['unescapeHtml'],
+                example: { input: '"&lt;b&gt;"', output: '<b>' },
+            }),
+            // -- Repeat --
+            {
+                command: 'repeat',
+                description: 'Repeat a string N times',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'count',
+                        aliases: ['n'],
+                        description: 'Number of repetitions (default: 2)',
+                        type: 'number',
+                        required: false,
+                    },
+                    {
+                        name: 'separator',
+                        aliases: ['sep'],
+                        description: 'Separator between repetitions (default: none)',
+                        type: 'string',
+                        required: false,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const count = Math.min(parseInt(command.args['count'] || command.args['n']) || 2, 1000);
+                    const sep = command.args['separator'] || command.args['sep'] || '';
+                    const result = Array(count).fill(text).join(sep);
+                    context.writer.writeln(`${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`);
+                    context.process.output(result);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Repeat a string multiple times');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string repeat <text> [--count=N] [--sep=S]', CliForegroundColor.Cyan)}`);
+                    writer.writeln();
+                    writer.writeln('📝 Examples:');
+                    writer.writeln(`  string repeat ha --count=3        ${writer.wrapInColor('# → hahaha', CliForegroundColor.Green)}`);
+                    writer.writeln(`  string repeat ab --n=3 --sep=-    ${writer.wrapInColor('# → ab-ab-ab', CliForegroundColor.Green)}`);
+                },
+            },
+            // -- Replace --
+            {
+                command: 'replace',
+                description: 'Replace occurrences in a string',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'find',
+                        aliases: ['f'],
+                        description: 'Text to find',
+                        type: 'string',
+                        required: true,
+                    },
+                    {
+                        name: 'with',
+                        aliases: ['w'],
+                        description: 'Replacement text',
+                        type: 'string',
+                        required: true,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const find = command.args['find'] || command.args['f'] || '';
+                    const replacement = command.args['with'] || command.args['w'] || '';
+                    if (!find) {
+                        context.writer.writeError('--find is required');
+                        context.process.exit(-1);
+                        return;
+                    }
+                    const result = text.split(find).join(replacement);
+                    context.writer.writeln(`${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`);
+                    context.process.output(result);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Replace all occurrences of a substring');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string replace <text> --find=<search> --with=<replacement>', CliForegroundColor.Cyan)}`);
+                    writer.writeln();
+                    writer.writeln('📝 Examples:');
+                    writer.writeln(`  string replace "hello world" --find=world --with=there`);
+                    writer.writeln(`  ${writer.wrapInColor('# → hello there', CliForegroundColor.Green)}`);
+                },
+            },
+            // -- Truncate --
+            {
+                command: 'truncate',
+                aliases: ['trunc'],
+                description: 'Truncate a string to a max length',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'length',
+                        aliases: ['l'],
+                        description: 'Maximum length (default: 30)',
+                        type: 'number',
+                        required: false,
+                    },
+                    {
+                        name: 'suffix',
+                        description: 'Omission suffix (default: ...)',
+                        type: 'string',
+                        required: false,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const length = parseInt(command.args['length'] || command.args['l']) || 30;
+                    const suffix = command.args['suffix'] ?? '...';
+                    const result = text.length > length
+                        ? text.substring(0, length - suffix.length) + suffix
+                        : text;
+                    context.writer.writeln(`${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`);
+                    context.process.output(result);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Truncate a string to a maximum length with an ellipsis');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string truncate <text> [--length=N] [--suffix=S]', CliForegroundColor.Cyan)}`);
+                },
+            },
+            // -- Pad --
+            {
+                command: 'pad',
+                description: 'Pad a string to a target length',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'length',
+                        aliases: ['l'],
+                        description: 'Target length',
+                        type: 'number',
+                        required: true,
+                    },
+                    {
+                        name: 'char',
+                        aliases: ['c'],
+                        description: 'Padding character (default: space)',
+                        type: 'string',
+                        required: false,
+                    },
+                    {
+                        name: 'side',
+                        description: 'Pad side: left, right, both (default: both)',
+                        type: 'string',
+                        required: false,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const length = parseInt(command.args['length'] || command.args['l']);
+                    const char = command.args['char'] || command.args['c'] || ' ';
+                    const side = command.args['side'] || 'both';
+                    if (isNaN(length)) {
+                        context.writer.writeError('--length is required');
+                        context.process.exit(-1);
+                        return;
+                    }
+                    let result;
+                    switch (side) {
+                        case 'left':
+                        case 'start':
+                            result = text.padStart(length, char);
+                            break;
+                        case 'right':
+                        case 'end':
+                            result = text.padEnd(length, char);
+                            break;
+                        default:
+                            result = lodash.pad(text, length, char);
+                            break;
+                    }
+                    context.writer.writeln(`${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}"${result}"`);
+                    context.process.output(result);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Pad a string to a target length');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string pad <text> --length=N [--char=C] [--side=left|right|both]', CliForegroundColor.Cyan)}`);
+                    writer.writeln();
+                    writer.writeln('📝 Examples:');
+                    writer.writeln(`  string pad hello --length=10 --char=. --side=right`);
+                    writer.writeln(`  ${writer.wrapInColor('# → "hello....."', CliForegroundColor.Green)}`);
+                },
+            },
+            // -- Split --
+            {
+                command: 'split',
+                description: 'Split a string by a delimiter',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'by',
+                        aliases: ['d', 'delimiter'],
+                        description: 'Delimiter to split by (default: space)',
+                        type: 'string',
+                        required: false,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const delimiter = command.args['by'] || command.args['d'] || command.args['delimiter'] || ' ';
+                    const parts = text.split(delimiter);
+                    const { writer } = context;
+                    parts.forEach((part, i) => {
+                        writer.writeln(`  ${writer.wrapInColor(String(i).padStart(3), CliForegroundColor.Yellow)}  ${part}`);
+                    });
+                    context.process.output(parts);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Split a string into parts by a delimiter');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string split <text> [--by=<delimiter>]', CliForegroundColor.Cyan)}`);
+                    writer.writeln();
+                    writer.writeln('📝 Examples:');
+                    writer.writeln(`  string split "a,b,c" --by=,      ${writer.wrapInColor('# → a  b  c', CliForegroundColor.Green)}`);
+                },
+            },
+            // -- Words --
+            {
+                command: 'words',
+                description: 'Split a string into words',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const words = lodash.words(text);
+                    const { writer } = context;
+                    writer.writeln(`${writer.wrapInColor(`${words.length} words:`, CliForegroundColor.Yellow)} ${words.join(', ')}`);
+                    context.process.output(words);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Split a string into its component words');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string words <text>', CliForegroundColor.Cyan)}`);
+                    writer.writeln();
+                    writer.writeln('📝 Examples:');
+                    writer.writeln(`  string words "helloWorld"         ${writer.wrapInColor('# → hello, World', CliForegroundColor.Green)}`);
+                    writer.writeln(`  string words "foo-bar_baz"        ${writer.wrapInColor('# → foo, bar, baz', CliForegroundColor.Green)}`);
+                },
+            },
+            // -- Analysis --
+            {
+                command: 'length',
+                aliases: ['len'],
+                description: 'Get the length of a string',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    context.writer.writeln(`${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${text.length}`);
+                    context.process.output(text.length);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Get the character count of a string');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string length <text>', CliForegroundColor.Cyan)}`);
+                },
+            },
+            {
+                command: 'wc',
+                aliases: ['wordcount', 'count'],
+                description: 'Count lines, words, characters, and bytes',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const { writer } = context;
+                    const lines = text.split(/\r?\n/).length;
+                    const wordCount = text.trim() ? text.trim().split(/\s+/).length : 0;
+                    const chars = text.length;
+                    const bytes = new TextEncoder().encode(text).length;
+                    writer.writeln(`  ${writer.wrapInColor('Lines:', CliForegroundColor.Cyan)}       ${lines}`);
+                    writer.writeln(`  ${writer.wrapInColor('Words:', CliForegroundColor.Cyan)}       ${wordCount}`);
+                    writer.writeln(`  ${writer.wrapInColor('Characters:', CliForegroundColor.Cyan)}  ${chars}`);
+                    writer.writeln(`  ${writer.wrapInColor('Bytes:', CliForegroundColor.Cyan)}       ${bytes}`);
+                    context.process.output({ lines, words: wordCount, chars, bytes });
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Count lines, words, characters, and bytes in text');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string wc <text>', CliForegroundColor.Cyan)}`);
+                },
+            },
+            {
+                command: 'includes',
+                aliases: ['contains', 'has'],
+                description: 'Check if a string contains a substring',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'find',
+                        aliases: ['f'],
+                        description: 'Substring to search for',
+                        type: 'string',
+                        required: true,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const find = command.args['find'] || command.args['f'] || '';
+                    const result = text.includes(find);
+                    const { writer } = context;
+                    if (result) {
+                        writer.writeSuccess(`"${find}" found in string`);
+                    }
+                    else {
+                        writer.writeError(`"${find}" not found in string`);
+                    }
+                    context.process.output(result);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Check if a string contains a given substring');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string includes <text> --find=<substring>', CliForegroundColor.Cyan)}`);
+                },
+            },
+            {
+                command: 'startsWith',
+                description: 'Check if a string starts with a prefix',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'find',
+                        aliases: ['f'],
+                        description: 'Prefix to check',
+                        type: 'string',
+                        required: true,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const find = command.args['find'] || command.args['f'] || '';
+                    const result = text.startsWith(find);
+                    const { writer } = context;
+                    writer.writeln(`${writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`);
+                    context.process.output(result);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Check if a string starts with a given prefix');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string startsWith <text> --find=<prefix>', CliForegroundColor.Cyan)}`);
+                },
+            },
+            {
+                command: 'endsWith',
+                description: 'Check if a string ends with a suffix',
+                allowUnlistedCommands: true,
+                valueRequired: true,
+                parameters: [
+                    {
+                        name: 'find',
+                        aliases: ['f'],
+                        description: 'Suffix to check',
+                        type: 'string',
+                        required: true,
+                    },
+                ],
+                processCommand: async (command, context) => {
+                    const text = (command.value || command.data || '');
+                    const find = command.args['find'] || command.args['f'] || '';
+                    const result = text.endsWith(find);
+                    const { writer } = context;
+                    writer.writeln(`${writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`);
+                    context.process.output(result);
+                },
+                writeDescription: (context) => {
+                    const { writer } = context;
+                    writer.writeln('Check if a string ends with a given suffix');
+                    writer.writeln();
+                    writer.writeln('📋 Usage:');
+                    writer.writeln(`  ${writer.wrapInColor('string endsWith <text> --find=<suffix>', CliForegroundColor.Cyan)}`);
+                },
             },
-        });
+        ];
     }
     async processCommand(command, context) {
         context.executor.showHelp(command, context);
     }
     writeDescription(context) {
-        context.writer.writeln("Provides string commands using lodash's string functions");
-        context.writer.writeln('Documentation: https://lodash.com/docs');
+        const { writer } = context;
+        writer.writeln('String manipulation and analysis commands');
+        writer.writeln();
+        writer.writeln(writer.wrapInColor('🔠 Case Conversions:', CliForegroundColor.Yellow));
+        writer.writeln(`  ${writer.wrapInColor('string upper', CliForegroundColor.Cyan)} / ${writer.wrapInColor('lower', CliForegroundColor.Cyan)} / ${writer.wrapInColor('capitalize', CliForegroundColor.Cyan)}`);
+        writer.writeln(`  ${writer.wrapInColor('string camelCase', CliForegroundColor.Cyan)} / ${writer.wrapInColor('kebabCase', CliForegroundColor.Cyan)} / ${writer.wrapInColor('snakeCase', CliForegroundColor.Cyan)} / ${writer.wrapInColor('startCase', CliForegroundColor.Cyan)}`);
+        writer.writeln();
+        writer.writeln(writer.wrapInColor('🔧 Transform:', CliForegroundColor.Yellow));
+        writer.writeln(`  ${writer.wrapInColor('string reverse', CliForegroundColor.Cyan)} / ${writer.wrapInColor('trim', CliForegroundColor.Cyan)} / ${writer.wrapInColor('slug', CliForegroundColor.Cyan)} / ${writer.wrapInColor('repeat', CliForegroundColor.Cyan)} / ${writer.wrapInColor('replace', CliForegroundColor.Cyan)} / ${writer.wrapInColor('truncate', CliForegroundColor.Cyan)}`);
+        writer.writeln(`  ${writer.wrapInColor('string pad', CliForegroundColor.Cyan)} / ${writer.wrapInColor('escape', CliForegroundColor.Cyan)} / ${writer.wrapInColor('unescape', CliForegroundColor.Cyan)}`);
+        writer.writeln();
+        writer.writeln(writer.wrapInColor('🔍 Analysis:', CliForegroundColor.Yellow));
+        writer.writeln(`  ${writer.wrapInColor('string length', CliForegroundColor.Cyan)} / ${writer.wrapInColor('wc', CliForegroundColor.Cyan)} / ${writer.wrapInColor('includes', CliForegroundColor.Cyan)} / ${writer.wrapInColor('startsWith', CliForegroundColor.Cyan)} / ${writer.wrapInColor('endsWith', CliForegroundColor.Cyan)}`);
+        writer.writeln(`  ${writer.wrapInColor('string split', CliForegroundColor.Cyan)} / ${writer.wrapInColor('words', CliForegroundColor.Cyan)}`);
+        writer.writeln();
+        writer.writeln('📝 Examples:');
+        writer.writeln(`  string camelCase "hello world"       ${writer.wrapInColor('# → helloWorld', CliForegroundColor.Green)}`);
+        writer.writeln(`  string reverse Hello                 ${writer.wrapInColor('# → olleH', CliForegroundColor.Green)}`);
+        writer.writeln(`  string slug "Hello World!"           ${writer.wrapInColor('# → hello-world', CliForegroundColor.Green)}`);
+        writer.writeln(`  string wc "some text here"           ${writer.wrapInColor('# word/char counts', CliForegroundColor.Green)}`);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CliStringCommandProcessor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CliStringCommandProcessor }); }
@@ -28,4 +543,4 @@ export class CliStringCommandProcessor {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CliStringCommandProcessor, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLXN0cmluZy1jb21tYW5kLXByb2Nlc3Nvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N0cmluZy9zcmMvbGliL3Byb2Nlc3NvcnMvY2xpLXN0cmluZy1jb21tYW5kLXByb2Nlc3Nvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFFSCxvQkFBb0IsRUFHcEIsZUFBZSxHQUNsQixNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sS0FBSyxDQUFDLE1BQU0sUUFBUSxDQUFDOztBQUc1QixNQUFNLE9BQU8seUJBQXlCO0lBU2xDO1FBUkEsWUFBTyxHQUFHLFFBQVEsQ0FBQztRQUVuQixnQkFBVyxHQUFHLGlCQUFpQixDQUFDO1FBRWhDLFdBQU0sR0FBRyxvQkFBb0IsQ0FBQztRQUU5QixlQUFVLEdBQXdDLEVBQUUsQ0FBQztRQUdqRCxJQUFJLENBQUMsVUFBVSxHQUFHLGVBQWUsQ0FBQyxRQUFRLENBQUUsQ0FBUyxDQUFDLE9BQU8sRUFBRTtZQUMzRCxNQUFNLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUU7Z0JBQ2pCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLENBQUMsS0FBSyxRQUFRLENBQUM7Z0JBQ3ZELE9BQU8sQ0FBQyxJQUFJLENBQUM7WUFDakIsQ0FBQztTQUNKLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFRCxLQUFLLENBQUMsY0FBYyxDQUNoQixPQUEwQixFQUMxQixPQUE2QjtRQUU3QixPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDaEQsQ0FBQztJQUVELGdCQUFnQixDQUFDLE9BQTZCO1FBQzFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUNsQiwwREFBMEQsQ0FDN0QsQ0FBQztRQUNGLE9BQU8sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLHdDQUF3QyxDQUFDLENBQUM7SUFDckUsQ0FBQzsrR0E5QlEseUJBQXlCO21IQUF6Qix5QkFBeUI7OzRGQUF6Qix5QkFBeUI7a0JBRHJDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1xuICAgIENsaVByb2Nlc3NDb21tYW5kLFxuICAgIERlZmF1bHRMaWJyYXJ5QXV0aG9yLFxuICAgIElDbGlDb21tYW5kUHJvY2Vzc29yLFxuICAgIElDbGlFeGVjdXRpb25Db250ZXh0LFxuICAgIE9iamVjdERlc2NyaWJlcixcbn0gZnJvbSAnQHFvZGFsaXMvY2xpLWNvcmUnO1xuaW1wb3J0ICogYXMgXyBmcm9tICdsb2Rhc2gnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQ2xpU3RyaW5nQ29tbWFuZFByb2Nlc3NvciBpbXBsZW1lbnRzIElDbGlDb21tYW5kUHJvY2Vzc29yIHtcbiAgICBjb21tYW5kID0gJ3N0cmluZyc7XG5cbiAgICBkZXNjcmlwdGlvbiA9ICdTdHJpbmcgY29tbWFuZHMnO1xuXG4gICAgYXV0aG9yID0gRGVmYXVsdExpYnJhcnlBdXRob3I7XG5cbiAgICBwcm9jZXNzb3JzPzogSUNsaUNvbW1hbmRQcm9jZXNzb3JbXSB8IHVuZGVmaW5lZCA9IFtdO1xuXG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgICAgIHRoaXMucHJvY2Vzc29ycyA9IE9iamVjdERlc2NyaWJlci5kZXNjcmliZSgoXyBhcyBhbnkpLmRlZmF1bHQsIHtcbiAgICAgICAgICAgIGZpbHRlcjogKHsgYXJncyB9KSA9PiB7XG4gICAgICAgICAgICAgICAgY29uc3Qgc2tpcCA9IGFyZ3MubGVuZ3RoID09PSAwIHx8IGFyZ3NbMF0gIT09ICdzdHJpbmcnO1xuICAgICAgICAgICAgICAgIHJldHVybiAhc2tpcDtcbiAgICAgICAgICAgIH0sXG4gICAgICAgIH0pO1xuICAgIH1cblxuICAgIGFzeW5jIHByb2Nlc3NDb21tYW5kKFxuICAgICAgICBjb21tYW5kOiBDbGlQcm9jZXNzQ29tbWFuZCxcbiAgICAgICAgY29udGV4dDogSUNsaUV4ZWN1dGlvbkNvbnRleHQsXG4gICAgKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgICAgIGNvbnRleHQuZXhlY3V0b3Iuc2hvd0hlbHAoY29tbWFuZCwgY29udGV4dCk7XG4gICAgfVxuXG4gICAgd3JpdGVEZXNjcmlwdGlvbihjb250ZXh0OiBJQ2xpRXhlY3V0aW9uQ29udGV4dCk6IHZvaWQge1xuICAgICAgICBjb250ZXh0LndyaXRlci53cml0ZWxuKFxuICAgICAgICAgICAgXCJQcm92aWRlcyBzdHJpbmcgY29tbWFuZHMgdXNpbmcgbG9kYXNoJ3Mgc3RyaW5nIGZ1bmN0aW9uc1wiLFxuICAgICAgICApO1xuICAgICAgICBjb250ZXh0LndyaXRlci53cml0ZWxuKCdEb2N1bWVudGF0aW9uOiBodHRwczovL2xvZGFzaC5jb20vZG9jcycpO1xuICAgIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-string-command-processor.js","sourceRoot":"","sources":["../../../../../projects/string/src/lib/processors/cli-string-command-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EACH,kBAAkB,EAGlB,oBAAoB,GAGvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;;AAE7C,MAAM,MAAM,GAAI,CAAS,CAAC,OAAO,IAAI,CAAC,CAAC;AAEvC;;GAEG;AACH,SAAS,eAAe,CACpB,OAAe,EACf,WAAmB,EACnB,SAAmC,EACnC,OAGC;IAED,OAAO;QACH,OAAO;QACP,OAAO,EAAE,OAAO,EAAE,OAAO;QACzB,WAAW;QACX,qBAAqB,EAAE,IAAI;QAC3B,aAAa,EAAE,IAAI;QACnB,cAAc,EAAE,KAAK,EACjB,GAAsB,EACtB,OAA6B,EAC/B,EAAE;YACA,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;YACrD,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;YAC/B,OAAO,CAAC,MAAM,CAAC,OAAO,CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAClF,CAAC;YACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC;QACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;YAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;YAC3B,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YAC5B,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,UAAU,OAAO,SAAS,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACjF,CAAC;YACF,IAAI,OAAO,EAAE,OAAO,EAAE;gBAClB,MAAM,CAAC,OAAO,EAAE,CAAC;gBACjB,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;gBAC/B,MAAM,CAAC,OAAO,CACV,YAAY,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,WAAW,CAAC,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAC7I,CAAC;aACL;QACL,CAAC;KACJ,CAAC;AACN,CAAC;AAGD,MAAM,OAAO,yBAAyB;IAmBlC;QAlBA,YAAO,GAAG,QAAQ,CAAC;QAEnB,YAAO,GAAG,CAAC,KAAK,CAAC,CAAC;QAElB,gBAAW,GAAG,8BAA8B,CAAC;QAE7C,WAAM,GAAG,oBAAoB,CAAC;QAE9B,YAAO,GAAG,eAAe,CAAC;QAE1B,eAAU,GAA4B,EAAE,CAAC;QAEzC,aAAQ,GAA0B;YAC9B,IAAI,EAAE,IAAI;YACV,mBAAmB,EAAE,QAAQ;YAC7B,kBAAkB,EAAE,QAAQ;SAC/B,CAAC;QAGE,IAAI,CAAC,UAAU,GAAG;YACd,yBAAyB;YACzB,eAAe,CAAC,OAAO,EAAE,sBAAsB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE;gBACrE,OAAO,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC;gBACjC,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE;aAC3D,CAAC;YACF,eAAe,CAAC,OAAO,EAAE,sBAAsB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE;gBACrE,OAAO,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC;gBACjC,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE;aAC3D,CAAC;YACF,eAAe,CAAC,YAAY,EAAE,6BAA6B,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE;gBACtF,OAAO,EAAE,CAAC,KAAK,CAAC;gBAChB,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE;aAC3D,CAAC;YACF,eAAe,CAAC,WAAW,EAAE,sBAAsB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;gBAC7E,OAAO,EAAE,CAAC,OAAO,CAAC;gBAClB,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE;aAC1D,CAAC;YACF,eAAe,CAAC,WAAW,EAAE,uBAAuB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;gBAC9E,OAAO,EAAE,CAAC,OAAO,CAAC;gBAClB,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE;aAC3D,CAAC;YACF,eAAe,CAAC,WAAW,EAAE,uBAAuB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;gBAC9E,OAAO,EAAE,CAAC,OAAO,CAAC;gBAClB,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE;aAC3D,CAAC;YACF,eAAe,CAAC,WAAW,EAAE,uBAAuB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;gBAC9E,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC;gBAC/B,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE;aAC3D,CAAC;YAEF,iBAAiB;YACjB,eAAe,CAAC,MAAM,EAAE,kCAAkC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE;gBACzE,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE;aACrD,CAAC;YACF,eAAe,CAAC,WAAW,EAAE,kCAAkC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,EAAE;gBACnF,OAAO,EAAE,CAAC,OAAO,CAAC;gBAClB,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE;aACnD,CAAC;YACF,eAAe,CAAC,SAAS,EAAE,gCAAgC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC7E,OAAO,EAAE,CAAC,OAAO,CAAC;gBAClB,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE;aACnD,CAAC;YAEF,kBAAkB;YAClB,eAAe,CAAC,SAAS,EAAE,kBAAkB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;gBAC7E,OAAO,EAAE,CAAC,KAAK,CAAC;gBAChB,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;aAC/C,CAAC;YACF,eAAe,CAAC,MAAM,EAAE,8BAA8B,EAAE,CAAC,CAAC,EAAE,EAAE,CAC1D,CAAC,CAAC,WAAW,EAAE;iBACV,SAAS,CAAC,KAAK,CAAC;iBAChB,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC;iBAC/B,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;iBAC3B,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,EAC1B;gBACI,OAAO,EAAE,CAAC,SAAS,CAAC;gBACpB,OAAO,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE;aAC9D,CACJ;YACD,eAAe,CAAC,QAAQ,EAAE,sBAAsB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;gBACvE,OAAO,EAAE,CAAC,YAAY,CAAC;gBACvB,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,uBAAuB,EAAE;aACrE,CAAC;YACF,eAAe,CAAC,UAAU,EAAE,wBAAwB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;gBAC7E,OAAO,EAAE,CAAC,cAAc,CAAC;gBACzB,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE;aACnD,CAAC;YAEF,eAAe;YACf;gBACI,OAAO,EAAE,QAAQ;gBACjB,WAAW,EAAE,yBAAyB;gBACtC,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,OAAO;wBACb,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,oCAAoC;wBACjD,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAClB;oBACD;wBACI,IAAI,EAAE,WAAW;wBACjB,OAAO,EAAE,CAAC,KAAK,CAAC;wBAChB,WAAW,EAAE,+CAA+C;wBAC5D,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAClB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;oBACxF,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;oBACnE,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACjD,OAAO,CAAC,MAAM,CAAC,OAAO,CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAClF,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;oBACjD,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,4CAA4C,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACnG,CAAC;oBACF,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;oBAC/B,MAAM,CAAC,OAAO,CACV,uCAAuC,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CACtG,CAAC;oBACF,MAAM,CAAC,OAAO,CACV,uCAAuC,MAAM,CAAC,WAAW,CAAC,cAAc,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CACxG,CAAC;gBACN,CAAC;aACJ;YAED,gBAAgB;YAChB;gBACI,OAAO,EAAE,SAAS;gBAClB,WAAW,EAAE,iCAAiC;gBAC9C,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,cAAc;wBAC3B,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACjB;oBACD;wBACI,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,kBAAkB;wBAC/B,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACjB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;oBAC7D,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;oBAEpE,IAAI,CAAC,IAAI,EAAE;wBACP,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC;wBAChD,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;wBACzB,OAAO;qBACV;oBAED,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oBAClD,OAAO,CAAC,MAAM,CAAC,OAAO,CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAClF,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,wCAAwC,CAAC,CAAC;oBACzD,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,4DAA4D,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACnH,CAAC;oBACF,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;oBAC/B,MAAM,CAAC,OAAO,CACV,0DAA0D,CAC7D,CAAC;oBACF,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CACzE,CAAC;gBACN,CAAC;aACJ;YAED,iBAAiB;YACjB;gBACI,OAAO,EAAE,UAAU;gBACnB,OAAO,EAAE,CAAC,OAAO,CAAC;gBAClB,WAAW,EAAE,mCAAmC;gBAChD,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,QAAQ;wBACd,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,8BAA8B;wBAC3C,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAClB;oBACD;wBACI,IAAI,EAAE,QAAQ;wBACd,WAAW,EAAE,gCAAgC;wBAC7C,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAClB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;oBAC3E,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC;oBAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,MAAM;wBAC/B,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM;wBACpD,CAAC,CAAC,IAAI,CAAC;oBACX,OAAO,CAAC,MAAM,CAAC,OAAO,CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAClF,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,wDAAwD,CAAC,CAAC;oBACzE,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,kDAAkD,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACzG,CAAC;gBACN,CAAC;aACJ;YAED,YAAY;YACZ;gBACI,OAAO,EAAE,KAAK;gBACd,WAAW,EAAE,iCAAiC;gBAC9C,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,QAAQ;wBACd,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,eAAe;wBAC5B,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACjB;oBACD;wBACI,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,oCAAoC;wBACjD,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAClB;oBACD;wBACI,IAAI,EAAE,MAAM;wBACZ,WAAW,EAAE,6CAA6C;wBAC1D,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAClB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;oBACrE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC;oBAC9D,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC;oBAE5C,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;wBACf,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAC;wBAClD,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;wBACzB,OAAO;qBACV;oBAED,IAAI,MAAc,CAAC;oBACnB,QAAQ,IAAI,EAAE;wBACV,KAAK,MAAM,CAAC;wBACZ,KAAK,OAAO;4BACR,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;4BACrC,MAAM;wBACV,KAAK,OAAO,CAAC;wBACb,KAAK,KAAK;4BACN,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;4BACnC,MAAM;wBACV;4BACI,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;4BACxC,MAAM;qBACb;oBAED,OAAO,CAAC,MAAM,CAAC,OAAO,CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CACpF,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,iCAAiC,CAAC,CAAC;oBAClD,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,kEAAkE,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACzH,CAAC;oBACF,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;oBAC/B,MAAM,CAAC,OAAO,CACV,sDAAsD,CACzD,CAAC;oBACF,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAC1E,CAAC;gBACN,CAAC;aACJ;YAED,cAAc;YACd;gBACI,OAAO,EAAE,OAAO;gBAChB,WAAW,EAAE,+BAA+B;gBAC5C,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,IAAI;wBACV,OAAO,EAAE,CAAC,GAAG,EAAE,WAAW,CAAC;wBAC3B,WAAW,EAAE,wCAAwC;wBACrD,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAClB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC;oBAC9F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;oBACpC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAE3B,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;wBACtB,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CACvF,CAAC;oBACN,CAAC,CAAC,CAAC;oBACH,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAClC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,0CAA0C,CAAC,CAAC;oBAC3D,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,wCAAwC,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAC/F,CAAC;oBACF,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;oBAC/B,MAAM,CAAC,OAAO,CACV,sCAAsC,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CACtG,CAAC;gBACN,CAAC;aACJ;YAED,cAAc;YACd;gBACI,OAAO,EAAE,OAAO;gBAChB,WAAW,EAAE,2BAA2B;gBACxC,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,KAAK,GAAa,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBAC3C,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAE3B,MAAM,CAAC,OAAO,CACV,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,MAAM,SAAS,EAAE,kBAAkB,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACnG,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAClC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,yCAAyC,CAAC,CAAC;oBAC1D,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,qBAAqB,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAC5E,CAAC;oBACF,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;oBAC/B,MAAM,CAAC,OAAO,CACV,uCAAuC,MAAM,CAAC,WAAW,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAC5G,CAAC;oBACF,MAAM,CAAC,OAAO,CACV,uCAAuC,MAAM,CAAC,WAAW,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAC7G,CAAC;gBACN,CAAC;aACJ;YAED,iBAAiB;YACjB;gBACI,OAAO,EAAE,QAAQ;gBACjB,OAAO,EAAE,CAAC,KAAK,CAAC;gBAChB,WAAW,EAAE,4BAA4B;gBACzC,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,OAAO,CAAC,MAAM,CAAC,OAAO,CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CACvF,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACxC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,qCAAqC,CAAC,CAAC;oBACtD,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,sBAAsB,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAC7E,CAAC;gBACN,CAAC;aACJ;YACD;gBACI,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC;gBAC/B,WAAW,EAAE,2CAA2C;gBACxD,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAE3B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;oBACzC,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;oBACpE,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;oBAC1B,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;oBAEpD,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,IAAI,CAAC,UAAU,KAAK,EAAE,CAC9E,CAAC;oBACF,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,IAAI,CAAC,UAAU,SAAS,EAAE,CAClF,CAAC;oBACF,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,kBAAkB,CAAC,IAAI,CAAC,KAAK,KAAK,EAAE,CAC9E,CAAC;oBACF,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,IAAI,CAAC,UAAU,KAAK,EAAE,CAC9E,CAAC;oBAEF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;gBACtE,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,mDAAmD,CAAC,CAAC;oBACpE,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACzE,CAAC;gBACN,CAAC;aACJ;YACD;gBACI,OAAO,EAAE,UAAU;gBACnB,OAAO,EAAE,CAAC,UAAU,EAAE,KAAK,CAAC;gBAC5B,WAAW,EAAE,wCAAwC;gBACrD,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,yBAAyB;wBACtC,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACjB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;oBAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;oBACnC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAE3B,IAAI,MAAM,EAAE;wBACR,MAAM,CAAC,YAAY,CAAC,IAAI,IAAI,mBAAmB,CAAC,CAAC;qBACpD;yBAAM;wBACH,MAAM,CAAC,UAAU,CAAC,IAAI,IAAI,uBAAuB,CAAC,CAAC;qBACtD;oBACD,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,8CAA8C,CAAC,CAAC;oBAC/D,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,2CAA2C,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAClG,CAAC;gBACN,CAAC;aACJ;YACD;gBACI,OAAO,EAAE,YAAY;gBACrB,WAAW,EAAE,wCAAwC;gBACrD,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,iBAAiB;wBAC9B,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACjB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;oBAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;oBACrC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAE3B,MAAM,CAAC,OAAO,CACV,GAAG,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAC1E,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,8CAA8C,CAAC,CAAC;oBAC/D,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,0CAA0C,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACjG,CAAC;gBACN,CAAC;aACJ;YACD;gBACI,OAAO,EAAE,UAAU;gBACnB,WAAW,EAAE,sCAAsC;gBACnD,qBAAqB,EAAE,IAAI;gBAC3B,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE;oBACR;wBACI,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,CAAC,GAAG,CAAC;wBACd,WAAW,EAAE,iBAAiB;wBAC9B,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACjB;iBACJ;gBACD,cAAc,EAAE,KAAK,EACjB,OAA0B,EAC1B,OAA6B,EAC/B,EAAE;oBACA,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,EAAE,CAAW,CAAC;oBAC7D,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;oBAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;oBACnC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAE3B,MAAM,CAAC,OAAO,CACV,GAAG,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAC1E,CAAC;oBACF,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnC,CAAC;gBACD,gBAAgB,EAAE,CAAC,OAA6B,EAAE,EAAE;oBAChD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,4CAA4C,CAAC,CAAC;oBAC7D,MAAM,CAAC,OAAO,EAAE,CAAC;oBACjB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBAC5B,MAAM,CAAC,OAAO,CACV,KAAK,MAAM,CAAC,WAAW,CAAC,wCAAwC,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAC/F,CAAC;gBACN,CAAC;aACJ;SACJ,CAAC;IACN,CAAC;IAED,KAAK,CAAC,cAAc,CAChB,OAA0B,EAC1B,OAA6B;QAE7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,gBAAgB,CAAC,OAA6B;QAC1C,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAC3B,MAAM,CAAC,OAAO,CAAC,2CAA2C,CAAC,CAAC;QAC5D,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,OAAO,CACV,MAAM,CAAC,WAAW,CAAC,sBAAsB,EAAE,kBAAkB,CAAC,MAAM,CAAC,CACxE,CAAC;QACF,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,cAAc,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC5M,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjR,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,OAAO,CACV,MAAM,CAAC,WAAW,CAAC,eAAe,EAAE,kBAAkB,CAAC,MAAM,CAAC,CACjE,CAAC;QACF,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC3X,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACzM,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,OAAO,CACV,MAAM,CAAC,WAAW,CAAC,cAAc,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAChE,CAAC;QACF,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,eAAe,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACpU,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,cAAc,EAAE,kBAAkB,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC7I,MAAM,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAC/B,MAAM,CAAC,OAAO,CAAC,0CAA0C,MAAM,CAAC,WAAW,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC3H,MAAM,CAAC,OAAO,CAAC,0CAA0C,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACtH,MAAM,CAAC,OAAO,CAAC,0CAA0C,MAAM,CAAC,WAAW,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC5H,MAAM,CAAC,OAAO,CAAC,0CAA0C,MAAM,CAAC,WAAW,CAAC,oBAAoB,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACnI,CAAC;+GAnoBQ,yBAAyB;mHAAzB,yBAAyB;;4FAAzB,yBAAyB;kBADrC,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n    CliForegroundColor,\n    CliProcessCommand,\n    CliProcessorMetadata,\n    DefaultLibraryAuthor,\n    ICliCommandProcessor,\n    ICliExecutionContext,\n} from '@qodalis/cli-core';\nimport * as _ from 'lodash';\nimport { LIBRARY_VERSION } from '../version';\n\nconst lodash = (_ as any).default || _;\n\n/**\n * Helper to create a simple string transform subcommand\n */\nfunction stringTransform(\n    command: string,\n    description: string,\n    transform: (text: string) => string,\n    options?: {\n        aliases?: string[];\n        example?: { input: string; output: string };\n    },\n): ICliCommandProcessor {\n    return {\n        command,\n        aliases: options?.aliases,\n        description,\n        allowUnlistedCommands: true,\n        valueRequired: true,\n        processCommand: async (\n            cmd: CliProcessCommand,\n            context: ICliExecutionContext,\n        ) => {\n            const text = (cmd.value || cmd.data || '') as string;\n            const result = transform(text);\n            context.writer.writeln(\n                `${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`,\n            );\n            context.process.output(result);\n        },\n        writeDescription: (context: ICliExecutionContext) => {\n            const { writer } = context;\n            writer.writeln(description);\n            writer.writeln();\n            writer.writeln('📋 Usage:');\n            writer.writeln(\n                `  ${writer.wrapInColor(`string ${command} <text>`, CliForegroundColor.Cyan)}`,\n            );\n            if (options?.example) {\n                writer.writeln();\n                writer.writeln('📝 Examples:');\n                writer.writeln(\n                    `  string ${command} ${options.example.input.padEnd(20)} ${writer.wrapInColor(`# → ${options.example.output}`, CliForegroundColor.Green)}`,\n                );\n            }\n        },\n    };\n}\n\n@Injectable()\nexport class CliStringCommandProcessor implements ICliCommandProcessor {\n    command = 'string';\n\n    aliases = ['str'];\n\n    description = 'String manipulation commands';\n\n    author = DefaultLibraryAuthor;\n\n    version = LIBRARY_VERSION;\n\n    processors?: ICliCommandProcessor[] = [];\n\n    metadata?: CliProcessorMetadata = {\n        icon: '🔤',\n        requiredCoreVersion: '0.0.16',\n        requiredCliVersion: '1.0.37',\n    };\n\n    constructor() {\n        this.processors = [\n            // -- Case conversions --\n            stringTransform('upper', 'Convert to UPPERCASE', (t) => t.toUpperCase(), {\n                aliases: ['uppercase', 'toUpper'],\n                example: { input: 'hello world', output: 'HELLO WORLD' },\n            }),\n            stringTransform('lower', 'Convert to lowercase', (t) => t.toLowerCase(), {\n                aliases: ['lowercase', 'toLower'],\n                example: { input: 'HELLO WORLD', output: 'hello world' },\n            }),\n            stringTransform('capitalize', 'Capitalize the first letter', (t) => lodash.capitalize(t), {\n                aliases: ['cap'],\n                example: { input: 'hello world', output: 'Hello world' },\n            }),\n            stringTransform('camelCase', 'Convert to camelCase', (t) => lodash.camelCase(t), {\n                aliases: ['camel'],\n                example: { input: 'hello world', output: 'helloWorld' },\n            }),\n            stringTransform('kebabCase', 'Convert to kebab-case', (t) => lodash.kebabCase(t), {\n                aliases: ['kebab'],\n                example: { input: 'Hello World', output: 'hello-world' },\n            }),\n            stringTransform('snakeCase', 'Convert to snake_case', (t) => lodash.snakeCase(t), {\n                aliases: ['snake'],\n                example: { input: 'Hello World', output: 'hello_world' },\n            }),\n            stringTransform('startCase', 'Convert to Start Case', (t) => lodash.startCase(t), {\n                aliases: ['title', 'titleCase'],\n                example: { input: 'hello-world', output: 'Hello World' },\n            }),\n\n            // -- Trimming --\n            stringTransform('trim', 'Remove whitespace from both ends', (t) => t.trim(), {\n                example: { input: '\"  hello  \"', output: 'hello' },\n            }),\n            stringTransform('trimStart', 'Remove whitespace from the start', (t) => t.trimStart(), {\n                aliases: ['ltrim'],\n                example: { input: '\"  hello\"', output: 'hello' },\n            }),\n            stringTransform('trimEnd', 'Remove whitespace from the end', (t) => t.trimEnd(), {\n                aliases: ['rtrim'],\n                example: { input: '\"hello  \"', output: 'hello' },\n            }),\n\n            // -- Transform --\n            stringTransform('reverse', 'Reverse a string', (t) => [...t].reverse().join(''), {\n                aliases: ['rev'],\n                example: { input: 'Hello', output: 'olleH' },\n            }),\n            stringTransform('slug', 'Convert to URL-friendly slug', (t) =>\n                t.toLowerCase()\n                    .normalize('NFD')\n                    .replace(/[\\u0300-\\u036f]/g, '')\n                    .replace(/[^a-z0-9]+/g, '-')\n                    .replace(/^-|-$/g, ''),\n                {\n                    aliases: ['slugify'],\n                    example: { input: '\"Hello World!\"', output: 'hello-world' },\n                },\n            ),\n            stringTransform('escape', 'Escape HTML entities', (t) => lodash.escape(t), {\n                aliases: ['escapeHtml'],\n                example: { input: '\"<b>hi</b>\"', output: '&lt;b&gt;hi&lt;/b&gt;' },\n            }),\n            stringTransform('unescape', 'Unescape HTML entities', (t) => lodash.unescape(t), {\n                aliases: ['unescapeHtml'],\n                example: { input: '\"&lt;b&gt;\"', output: '<b>' },\n            }),\n\n            // -- Repeat --\n            {\n                command: 'repeat',\n                description: 'Repeat a string N times',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'count',\n                        aliases: ['n'],\n                        description: 'Number of repetitions (default: 2)',\n                        type: 'number',\n                        required: false,\n                    },\n                    {\n                        name: 'separator',\n                        aliases: ['sep'],\n                        description: 'Separator between repetitions (default: none)',\n                        type: 'string',\n                        required: false,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const count = Math.min(parseInt(command.args['count'] || command.args['n']) || 2, 1000);\n                    const sep = command.args['separator'] || command.args['sep'] || '';\n                    const result = Array(count).fill(text).join(sep);\n                    context.writer.writeln(\n                        `${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`,\n                    );\n                    context.process.output(result);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Repeat a string multiple times');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string repeat <text> [--count=N] [--sep=S]', CliForegroundColor.Cyan)}`,\n                    );\n                    writer.writeln();\n                    writer.writeln('📝 Examples:');\n                    writer.writeln(\n                        `  string repeat ha --count=3        ${writer.wrapInColor('# → hahaha', CliForegroundColor.Green)}`,\n                    );\n                    writer.writeln(\n                        `  string repeat ab --n=3 --sep=-    ${writer.wrapInColor('# → ab-ab-ab', CliForegroundColor.Green)}`,\n                    );\n                },\n            },\n\n            // -- Replace --\n            {\n                command: 'replace',\n                description: 'Replace occurrences in a string',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'find',\n                        aliases: ['f'],\n                        description: 'Text to find',\n                        type: 'string',\n                        required: true,\n                    },\n                    {\n                        name: 'with',\n                        aliases: ['w'],\n                        description: 'Replacement text',\n                        type: 'string',\n                        required: true,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const find = command.args['find'] || command.args['f'] || '';\n                    const replacement = command.args['with'] || command.args['w'] || '';\n\n                    if (!find) {\n                        context.writer.writeError('--find is required');\n                        context.process.exit(-1);\n                        return;\n                    }\n\n                    const result = text.split(find).join(replacement);\n                    context.writer.writeln(\n                        `${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`,\n                    );\n                    context.process.output(result);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Replace all occurrences of a substring');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string replace <text> --find=<search> --with=<replacement>', CliForegroundColor.Cyan)}`,\n                    );\n                    writer.writeln();\n                    writer.writeln('📝 Examples:');\n                    writer.writeln(\n                        `  string replace \"hello world\" --find=world --with=there`,\n                    );\n                    writer.writeln(\n                        `  ${writer.wrapInColor('# → hello there', CliForegroundColor.Green)}`,\n                    );\n                },\n            },\n\n            // -- Truncate --\n            {\n                command: 'truncate',\n                aliases: ['trunc'],\n                description: 'Truncate a string to a max length',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'length',\n                        aliases: ['l'],\n                        description: 'Maximum length (default: 30)',\n                        type: 'number',\n                        required: false,\n                    },\n                    {\n                        name: 'suffix',\n                        description: 'Omission suffix (default: ...)',\n                        type: 'string',\n                        required: false,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const length = parseInt(command.args['length'] || command.args['l']) || 30;\n                    const suffix = command.args['suffix'] ?? '...';\n                    const result = text.length > length\n                        ? text.substring(0, length - suffix.length) + suffix\n                        : text;\n                    context.writer.writeln(\n                        `${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`,\n                    );\n                    context.process.output(result);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Truncate a string to a maximum length with an ellipsis');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string truncate <text> [--length=N] [--suffix=S]', CliForegroundColor.Cyan)}`,\n                    );\n                },\n            },\n\n            // -- Pad --\n            {\n                command: 'pad',\n                description: 'Pad a string to a target length',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'length',\n                        aliases: ['l'],\n                        description: 'Target length',\n                        type: 'number',\n                        required: true,\n                    },\n                    {\n                        name: 'char',\n                        aliases: ['c'],\n                        description: 'Padding character (default: space)',\n                        type: 'string',\n                        required: false,\n                    },\n                    {\n                        name: 'side',\n                        description: 'Pad side: left, right, both (default: both)',\n                        type: 'string',\n                        required: false,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const length = parseInt(command.args['length'] || command.args['l']);\n                    const char = command.args['char'] || command.args['c'] || ' ';\n                    const side = command.args['side'] || 'both';\n\n                    if (isNaN(length)) {\n                        context.writer.writeError('--length is required');\n                        context.process.exit(-1);\n                        return;\n                    }\n\n                    let result: string;\n                    switch (side) {\n                        case 'left':\n                        case 'start':\n                            result = text.padStart(length, char);\n                            break;\n                        case 'right':\n                        case 'end':\n                            result = text.padEnd(length, char);\n                            break;\n                        default:\n                            result = lodash.pad(text, length, char);\n                            break;\n                    }\n\n                    context.writer.writeln(\n                        `${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}\"${result}\"`,\n                    );\n                    context.process.output(result);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Pad a string to a target length');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string pad <text> --length=N [--char=C] [--side=left|right|both]', CliForegroundColor.Cyan)}`,\n                    );\n                    writer.writeln();\n                    writer.writeln('📝 Examples:');\n                    writer.writeln(\n                        `  string pad hello --length=10 --char=. --side=right`,\n                    );\n                    writer.writeln(\n                        `  ${writer.wrapInColor('# → \"hello.....\"', CliForegroundColor.Green)}`,\n                    );\n                },\n            },\n\n            // -- Split --\n            {\n                command: 'split',\n                description: 'Split a string by a delimiter',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'by',\n                        aliases: ['d', 'delimiter'],\n                        description: 'Delimiter to split by (default: space)',\n                        type: 'string',\n                        required: false,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const delimiter = command.args['by'] || command.args['d'] || command.args['delimiter'] || ' ';\n                    const parts = text.split(delimiter);\n                    const { writer } = context;\n\n                    parts.forEach((part, i) => {\n                        writer.writeln(\n                            `  ${writer.wrapInColor(String(i).padStart(3), CliForegroundColor.Yellow)}  ${part}`,\n                        );\n                    });\n                    context.process.output(parts);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Split a string into parts by a delimiter');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string split <text> [--by=<delimiter>]', CliForegroundColor.Cyan)}`,\n                    );\n                    writer.writeln();\n                    writer.writeln('📝 Examples:');\n                    writer.writeln(\n                        `  string split \"a,b,c\" --by=,      ${writer.wrapInColor('# → a  b  c', CliForegroundColor.Green)}`,\n                    );\n                },\n            },\n\n            // -- Words --\n            {\n                command: 'words',\n                description: 'Split a string into words',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const words: string[] = lodash.words(text);\n                    const { writer } = context;\n\n                    writer.writeln(\n                        `${writer.wrapInColor(`${words.length} words:`, CliForegroundColor.Yellow)} ${words.join(', ')}`,\n                    );\n                    context.process.output(words);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Split a string into its component words');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string words <text>', CliForegroundColor.Cyan)}`,\n                    );\n                    writer.writeln();\n                    writer.writeln('📝 Examples:');\n                    writer.writeln(\n                        `  string words \"helloWorld\"         ${writer.wrapInColor('# → hello, World', CliForegroundColor.Green)}`,\n                    );\n                    writer.writeln(\n                        `  string words \"foo-bar_baz\"        ${writer.wrapInColor('# → foo, bar, baz', CliForegroundColor.Green)}`,\n                    );\n                },\n            },\n\n            // -- Analysis --\n            {\n                command: 'length',\n                aliases: ['len'],\n                description: 'Get the length of a string',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    context.writer.writeln(\n                        `${context.writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${text.length}`,\n                    );\n                    context.process.output(text.length);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Get the character count of a string');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string length <text>', CliForegroundColor.Cyan)}`,\n                    );\n                },\n            },\n            {\n                command: 'wc',\n                aliases: ['wordcount', 'count'],\n                description: 'Count lines, words, characters, and bytes',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const { writer } = context;\n\n                    const lines = text.split(/\\r?\\n/).length;\n                    const wordCount = text.trim() ? text.trim().split(/\\s+/).length : 0;\n                    const chars = text.length;\n                    const bytes = new TextEncoder().encode(text).length;\n\n                    writer.writeln(\n                        `  ${writer.wrapInColor('Lines:', CliForegroundColor.Cyan)}       ${lines}`,\n                    );\n                    writer.writeln(\n                        `  ${writer.wrapInColor('Words:', CliForegroundColor.Cyan)}       ${wordCount}`,\n                    );\n                    writer.writeln(\n                        `  ${writer.wrapInColor('Characters:', CliForegroundColor.Cyan)}  ${chars}`,\n                    );\n                    writer.writeln(\n                        `  ${writer.wrapInColor('Bytes:', CliForegroundColor.Cyan)}       ${bytes}`,\n                    );\n\n                    context.process.output({ lines, words: wordCount, chars, bytes });\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Count lines, words, characters, and bytes in text');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string wc <text>', CliForegroundColor.Cyan)}`,\n                    );\n                },\n            },\n            {\n                command: 'includes',\n                aliases: ['contains', 'has'],\n                description: 'Check if a string contains a substring',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'find',\n                        aliases: ['f'],\n                        description: 'Substring to search for',\n                        type: 'string',\n                        required: true,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const find = command.args['find'] || command.args['f'] || '';\n                    const result = text.includes(find);\n                    const { writer } = context;\n\n                    if (result) {\n                        writer.writeSuccess(`\"${find}\" found in string`);\n                    } else {\n                        writer.writeError(`\"${find}\" not found in string`);\n                    }\n                    context.process.output(result);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Check if a string contains a given substring');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string includes <text> --find=<substring>', CliForegroundColor.Cyan)}`,\n                    );\n                },\n            },\n            {\n                command: 'startsWith',\n                description: 'Check if a string starts with a prefix',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'find',\n                        aliases: ['f'],\n                        description: 'Prefix to check',\n                        type: 'string',\n                        required: true,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const find = command.args['find'] || command.args['f'] || '';\n                    const result = text.startsWith(find);\n                    const { writer } = context;\n\n                    writer.writeln(\n                        `${writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`,\n                    );\n                    context.process.output(result);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Check if a string starts with a given prefix');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string startsWith <text> --find=<prefix>', CliForegroundColor.Cyan)}`,\n                    );\n                },\n            },\n            {\n                command: 'endsWith',\n                description: 'Check if a string ends with a suffix',\n                allowUnlistedCommands: true,\n                valueRequired: true,\n                parameters: [\n                    {\n                        name: 'find',\n                        aliases: ['f'],\n                        description: 'Suffix to check',\n                        type: 'string',\n                        required: true,\n                    },\n                ],\n                processCommand: async (\n                    command: CliProcessCommand,\n                    context: ICliExecutionContext,\n                ) => {\n                    const text = (command.value || command.data || '') as string;\n                    const find = command.args['find'] || command.args['f'] || '';\n                    const result = text.endsWith(find);\n                    const { writer } = context;\n\n                    writer.writeln(\n                        `${writer.wrapInColor('Result: ', CliForegroundColor.Yellow)}${result}`,\n                    );\n                    context.process.output(result);\n                },\n                writeDescription: (context: ICliExecutionContext) => {\n                    const { writer } = context;\n                    writer.writeln('Check if a string ends with a given suffix');\n                    writer.writeln();\n                    writer.writeln('📋 Usage:');\n                    writer.writeln(\n                        `  ${writer.wrapInColor('string endsWith <text> --find=<suffix>', CliForegroundColor.Cyan)}`,\n                    );\n                },\n            },\n        ];\n    }\n\n    async processCommand(\n        command: CliProcessCommand,\n        context: ICliExecutionContext,\n    ): Promise<void> {\n        context.executor.showHelp(command, context);\n    }\n\n    writeDescription(context: ICliExecutionContext): void {\n        const { writer } = context;\n        writer.writeln('String manipulation and analysis commands');\n        writer.writeln();\n        writer.writeln(\n            writer.wrapInColor('🔠 Case Conversions:', CliForegroundColor.Yellow),\n        );\n        writer.writeln(`  ${writer.wrapInColor('string upper', CliForegroundColor.Cyan)} / ${writer.wrapInColor('lower', CliForegroundColor.Cyan)} / ${writer.wrapInColor('capitalize', CliForegroundColor.Cyan)}`);\n        writer.writeln(`  ${writer.wrapInColor('string camelCase', CliForegroundColor.Cyan)} / ${writer.wrapInColor('kebabCase', CliForegroundColor.Cyan)} / ${writer.wrapInColor('snakeCase', CliForegroundColor.Cyan)} / ${writer.wrapInColor('startCase', CliForegroundColor.Cyan)}`);\n        writer.writeln();\n        writer.writeln(\n            writer.wrapInColor('🔧 Transform:', CliForegroundColor.Yellow),\n        );\n        writer.writeln(`  ${writer.wrapInColor('string reverse', CliForegroundColor.Cyan)} / ${writer.wrapInColor('trim', CliForegroundColor.Cyan)} / ${writer.wrapInColor('slug', CliForegroundColor.Cyan)} / ${writer.wrapInColor('repeat', CliForegroundColor.Cyan)} / ${writer.wrapInColor('replace', CliForegroundColor.Cyan)} / ${writer.wrapInColor('truncate', CliForegroundColor.Cyan)}`);\n        writer.writeln(`  ${writer.wrapInColor('string pad', CliForegroundColor.Cyan)} / ${writer.wrapInColor('escape', CliForegroundColor.Cyan)} / ${writer.wrapInColor('unescape', CliForegroundColor.Cyan)}`);\n        writer.writeln();\n        writer.writeln(\n            writer.wrapInColor('🔍 Analysis:', CliForegroundColor.Yellow),\n        );\n        writer.writeln(`  ${writer.wrapInColor('string length', CliForegroundColor.Cyan)} / ${writer.wrapInColor('wc', CliForegroundColor.Cyan)} / ${writer.wrapInColor('includes', CliForegroundColor.Cyan)} / ${writer.wrapInColor('startsWith', CliForegroundColor.Cyan)} / ${writer.wrapInColor('endsWith', CliForegroundColor.Cyan)}`);\n        writer.writeln(`  ${writer.wrapInColor('string split', CliForegroundColor.Cyan)} / ${writer.wrapInColor('words', CliForegroundColor.Cyan)}`);\n        writer.writeln();\n        writer.writeln('📝 Examples:');\n        writer.writeln(`  string camelCase \"hello world\"       ${writer.wrapInColor('# → helloWorld', CliForegroundColor.Green)}`);\n        writer.writeln(`  string reverse Hello                 ${writer.wrapInColor('# → olleH', CliForegroundColor.Green)}`);\n        writer.writeln(`  string slug \"Hello World!\"           ${writer.wrapInColor('# → hello-world', CliForegroundColor.Green)}`);\n        writer.writeln(`  string wc \"some text here\"           ${writer.wrapInColor('# word/char counts', CliForegroundColor.Green)}`);\n    }\n}\n"]}