@qodalis/cli-guid 1.0.8 → 2.0.0-beta.1

package/package.json

@@ -1,44 +1,36 @@
 {
   "name": "@qodalis/cli-guid",
-  "version": "1.0.8",
-  "description": "An Angular CLI extension for generating and validating GUIDs.",
+  "version": "2.0.0-beta.1",
+  "description": "@qodalis/cli extension for generating and validating GUIDs.",
   "author": "Nicolae Lupei, Qodalis Solutions",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/qodalis-solutions/angular-web-cli"
+    "url": "https://github.com/qodalis-solutions/web-cli"
   },
   "homepage": "https://qodalis.com",
   "keywords": [
-    "angular",
     "cli",
     "qodalis",
     "terminal",
-    "guid"
+    "guid",
+    "uuid",
+    "generator"
   ],
   "umd": "./umd/index.js",
   "unpkg": "./umd/index.js",
-  "peerDependencies": {
-    "@angular/common": "^16.2.0",
-    "@angular/core": "^16.2.0"
-  },
   "dependencies": {
-    "tslib": "^2.3.0",
-    "@qodalis/cli-core": "^0.0.5",
-    "@qodalis/angular-cli": "^1.0.14"
+    "@qodalis/cli-core": "2.0.0-beta.1"
   },
   "sideEffects": false,
-  "module": "fesm2022/qodalis-cli-guid.mjs",
-  "typings": "index.d.ts",
+  "main": "./public-api.js",
+  "module": "./public-api.mjs",
+  "types": "./public-api.d.ts",
   "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
     ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/qodalis-cli-guid.mjs",
-      "esm": "./esm2022/qodalis-cli-guid.mjs",
-      "default": "./fesm2022/qodalis-cli-guid.mjs"
+      "types": "./public-api.d.ts",
+      "import": "./public-api.mjs",
+      "require": "./public-api.js"
     }
   }
-}
+}

package/public-api.d.mts

@@ -0,0 +1,45 @@
+import * as _qodalis_cli_core from '@qodalis/cli-core';
+import { ICliCommandProcessor, CliProcessorMetadata, CliProcessCommand, ICliExecutionContext, ICliModule } from '@qodalis/cli-core';
+
+/**
+ * Generates a v4 UUID using crypto.getRandomValues when available,
+ * falling back to Math.random.
+ */
+declare const generateGUID: () => string;
+/**
+ * Validates a UUID v4 string.
+ */
+declare const validateGUID: (guid: string) => boolean;
+/**
+ * Validates any UUID version (v1-v5, nil).
+ */
+declare const validateAnyGUID: (guid: string) => boolean;
+/** The nil UUID (all zeros). */
+declare const NIL_GUID = "00000000-0000-0000-0000-000000000000";
+/**
+ * Detects the version of a UUID string.
+ * Returns the version number (1-5) or 0 for nil, or null if invalid.
+ */
+declare const detectGUIDVersion: (guid: string) => number | null;
+type GuidFormat = 'default' | 'uppercase' | 'braces' | 'parentheses' | 'digits' | 'urn';
+/**
+ * Formats a UUID string into different representations.
+ */
+declare const formatGUID: (guid: string, format: GuidFormat) => string;
+
+declare class CliGuidCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    version: string;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare const guidModule: ICliModule;
+
+export { CliGuidCommandProcessor, type GuidFormat, NIL_GUID, detectGUIDVersion, formatGUID, generateGUID, guidModule, validateAnyGUID, validateGUID };

package/public-api.d.ts

@@ -1,3 +1,45 @@
-export * from './lib/cli-guid.module';
-export * from './lib/utilities';
-export * from './lib/processors/cli-guid-command-processor';
+import * as _qodalis_cli_core from '@qodalis/cli-core';
+import { ICliCommandProcessor, CliProcessorMetadata, CliProcessCommand, ICliExecutionContext, ICliModule } from '@qodalis/cli-core';
+
+/**
+ * Generates a v4 UUID using crypto.getRandomValues when available,
+ * falling back to Math.random.
+ */
+declare const generateGUID: () => string;
+/**
+ * Validates a UUID v4 string.
+ */
+declare const validateGUID: (guid: string) => boolean;
+/**
+ * Validates any UUID version (v1-v5, nil).
+ */
+declare const validateAnyGUID: (guid: string) => boolean;
+/** The nil UUID (all zeros). */
+declare const NIL_GUID = "00000000-0000-0000-0000-000000000000";
+/**
+ * Detects the version of a UUID string.
+ * Returns the version number (1-5) or 0 for nil, or null if invalid.
+ */
+declare const detectGUIDVersion: (guid: string) => number | null;
+type GuidFormat = 'default' | 'uppercase' | 'braces' | 'parentheses' | 'digits' | 'urn';
+/**
+ * Formats a UUID string into different representations.
+ */
+declare const formatGUID: (guid: string, format: GuidFormat) => string;
+
+declare class CliGuidCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    aliases: string[];
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    version: string;
+    processors?: ICliCommandProcessor[];
+    metadata?: CliProcessorMetadata;
+    constructor();
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+}
+
+declare const guidModule: ICliModule;
+
+export { CliGuidCommandProcessor, type GuidFormat, NIL_GUID, detectGUIDVersion, formatGUID, generateGUID, guidModule, validateAnyGUID, validateGUID };

package/public-api.js

@@ -0,0 +1,541 @@
+'use strict';
+
+var cliCore = require('@qodalis/cli-core');
+
+// src/lib/utilities/index.ts
+var generateGUID = () => {
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(
+      bytes,
+      (b) => b.toString(16).padStart(2, "0")
+    ).join("");
+    return [
+      hex.slice(0, 8),
+      hex.slice(8, 12),
+      hex.slice(12, 16),
+      hex.slice(16, 20),
+      hex.slice(20, 32)
+    ].join("-");
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+    const random = Math.random() * 16 | 0;
+    const value = char === "x" ? random : random & 3 | 8;
+    return value.toString(16);
+  });
+};
+var validateGUID = (guid) => {
+  const guidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+  return guidRegex.test(guid);
+};
+var validateAnyGUID = (guid) => {
+  const guidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+  return guidRegex.test(guid);
+};
+var NIL_GUID = "00000000-0000-0000-0000-000000000000";
+var detectGUIDVersion = (guid) => {
+  if (!validateAnyGUID(guid)) {
+    return null;
+  }
+  if (guid === NIL_GUID) {
+    return 0;
+  }
+  const versionChar = guid.charAt(14);
+  const version = parseInt(versionChar, 16);
+  return version >= 1 && version <= 5 ? version : null;
+};
+var formatGUID = (guid, format) => {
+  const clean = guid.replace(/[-{}() ]/g, "").toLowerCase();
+  const d = `${clean.slice(0, 8)}-${clean.slice(8, 12)}-${clean.slice(12, 16)}-${clean.slice(16, 20)}-${clean.slice(20, 32)}`;
+  switch (format) {
+    case "uppercase":
+      return d.toUpperCase();
+    case "braces":
+      return `{${d}}`;
+    case "parentheses":
+      return `(${d})`;
+    case "digits":
+      return clean;
+    case "urn":
+      return `urn:uuid:${d}`;
+    case "default":
+    default:
+      return d;
+  }
+};
+
+// src/lib/version.ts
+var LIBRARY_VERSION = "2.0.0-beta.1";
+var API_VERSION = 2;
+
+// src/lib/processors/cli-guid-command-processor.ts
+var GUID_FORMATS = [
+  "default",
+  "uppercase",
+  "braces",
+  "parentheses",
+  "digits",
+  "urn"
+];
+var CliGuidCommandProcessor = class {
+  constructor() {
+    this.command = "guid";
+    this.aliases = ["uuid"];
+    this.description = "Generate, validate, format, and inspect UUIDs";
+    this.author = cliCore.DefaultLibraryAuthor;
+    this.version = LIBRARY_VERSION;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F194}",
+      module: "guid"
+    };
+    this.processors = [
+      // --- new ---
+      {
+        command: "new",
+        aliases: ["gen", "generate"],
+        description: "Generate one or more UUIDs",
+        parameters: [
+          {
+            name: "copy",
+            aliases: ["c"],
+            description: "Copy the result to the clipboard",
+            required: false,
+            type: "boolean"
+          },
+          {
+            name: "count",
+            aliases: ["n"],
+            description: "Number of UUIDs to generate",
+            defaultValue: "1",
+            required: false,
+            type: "number"
+          },
+          {
+            name: "format",
+            aliases: ["f"],
+            description: `Output format: ${GUID_FORMATS.join(", ")}`,
+            defaultValue: "default",
+            required: false,
+            type: "string"
+          }
+        ],
+        processCommand: async (command, context) => {
+          const count = command.args["count"] ? parseInt(command.args["count"]) : 1;
+          if (isNaN(count) || count < 1 || count > 1e3) {
+            context.writer.writeError(
+              "Count must be a number between 1 and 1000"
+            );
+            return;
+          }
+          const format = command.args["format"] || "default";
+          if (!GUID_FORMATS.includes(format)) {
+            context.writer.writeError(
+              `Unknown format "${format}". Available: ${GUID_FORMATS.join(", ")}`
+            );
+            return;
+          }
+          const copyToClipboard = command.args["copy"] || command.args["c"];
+          const items = [];
+          for (let i = 0; i < count; i++) {
+            const guid = formatGUID(generateGUID(), format);
+            context.writer.writeln(guid);
+            items.push(guid);
+          }
+          if (copyToClipboard) {
+            await context.clipboard.write(items.join("\n"));
+            context.writer.writeInfo(
+              items.length === 1 ? "Copied to clipboard" : `${items.length} UUIDs copied to clipboard`
+            );
+          }
+          context.process.output(
+            items.length === 1 ? items[0] : items
+          );
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Generate one or more UUIDs (v4)");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("guid new", cliCore.CliForegroundColor.Cyan)}                           Generate a single UUID`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("guid new --count=5", cliCore.CliForegroundColor.Cyan)}                   Generate 5 UUIDs`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("guid new --copy", cliCore.CliForegroundColor.Cyan)}                      Generate and copy`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("guid new --format=uppercase", cliCore.CliForegroundColor.Cyan)}          Uppercase output`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("guid new --format=braces", cliCore.CliForegroundColor.Cyan)}             {wrapped} format`
+          );
+          writer.writeln();
+          writer.writeln(
+            `Formats: ${writer.wrapInColor(GUID_FORMATS.join(", "), cliCore.CliForegroundColor.Yellow)}`
+          );
+        }
+      },
+      // --- validate ---
+      {
+        command: "validate",
+        aliases: ["check"],
+        description: "Validate a UUID string",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "strict",
+            description: "Only accept v4 UUIDs (default: accept any version)",
+            required: false,
+            type: "boolean"
+          }
+        ],
+        processCommand: async (command, context) => {
+          const input = command.value;
+          const strict = command.args["strict"];
+          const isValid = strict ? validateGUID(input) : validateAnyGUID(input);
+          if (isValid) {
+            const version = detectGUIDVersion(input);
+            const versionLabel = version === 0 ? "nil" : version ? `v${version}` : "unknown version";
+            context.writer.writeSuccess(
+              `Valid UUID (${versionLabel})`
+            );
+            context.process.output({ valid: true, version });
+          } else {
+            context.writer.writeError(
+              `Invalid UUID: ${input}`
+            );
+            context.process.output({
+              valid: false,
+              version: null
+            });
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Validate a UUID string and detect its version");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("guid validate <uuid>", cliCore.CliForegroundColor.Cyan)}                  Check any UUID`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("guid validate <uuid> --strict", cliCore.CliForegroundColor.Cyan)}         Only accept v4`
+          );
+        }
+      },
+      // --- format ---
+      {
+        command: "format",
+        aliases: ["fmt"],
+        description: "Convert a UUID to a different format",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "to",
+            aliases: ["t"],
+            description: `Target format: ${GUID_FORMATS.join(", ")}`,
+            defaultValue: "default",
+            required: false,
+            type: "string"
+          },
+          {
+            name: "copy",
+            aliases: ["c"],
+            description: "Copy the result to the clipboard",
+            required: false,
+            type: "boolean"
+          }
+        ],
+        processCommand: async (command, context) => {
+          const input = command.value;
+          const clean = input.replace(/[-{}()urn:uuid ]/g, "");
+          if (!/^[0-9a-fA-F]{32}$/.test(clean)) {
+            context.writer.writeError(
+              `Cannot parse as UUID: ${input}`
+            );
+            return;
+          }
+          const format = command.args["to"] || "default";
+          if (!GUID_FORMATS.includes(format)) {
+            context.writer.writeError(
+              `Unknown format "${format}". Available: ${GUID_FORMATS.join(", ")}`
+            );
+            return;
+          }
+          const normalized = `${clean.slice(0, 8)}-${clean.slice(8, 12)}-${clean.slice(12, 16)}-${clean.slice(16, 20)}-${clean.slice(20, 32)}`.toLowerCase();
+          const result = formatGUID(normalized, format);
+          context.writer.writeln(result);
+          if (command.args["copy"] || command.args["c"]) {
+            await context.clipboard.write(result);
+            context.writer.writeInfo("Copied to clipboard");
+          }
+          context.process.output(result);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Convert a UUID between different formats");
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("guid format <uuid> --to=braces", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("guid format <uuid> --to=urn", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(
+            `Formats: ${writer.wrapInColor(GUID_FORMATS.join(", "), cliCore.CliForegroundColor.Yellow)}`
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4DD} Examples:");
+          writer.writeln(
+            `  guid format 550e8400-e29b-41d4-a716-446655440000 --to=braces`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("\u2192 {550e8400-e29b-41d4-a716-446655440000}", cliCore.CliForegroundColor.Green)}`
+          );
+        }
+      },
+      // --- inspect ---
+      {
+        command: "inspect",
+        aliases: ["info", "parse"],
+        description: "Show detailed information about a UUID",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const input = command.value;
+          const { writer } = context;
+          if (!validateAnyGUID(input)) {
+            writer.writeError(`Invalid UUID: ${input}`);
+            return;
+          }
+          const version = detectGUIDVersion(input);
+          const isNil = input === NIL_GUID;
+          const lower = input.toLowerCase();
+          const variantBits = parseInt(lower.charAt(19), 16);
+          let variant;
+          if ((variantBits & 8) === 0) {
+            variant = "NCS (reserved)";
+          } else if ((variantBits & 12) === 8) {
+            variant = "RFC 4122";
+          } else if ((variantBits & 14) === 12) {
+            variant = "Microsoft (reserved)";
+          } else {
+            variant = "Future (reserved)";
+          }
+          writer.writeln(
+            writer.wrapInColor(
+              "\u2500\u2500 UUID Details \u2500\u2500",
+              cliCore.CliForegroundColor.Cyan
+            )
+          );
+          writer.writeln();
+          writer.writeln(
+            `  ${writer.wrapInColor("Input:", cliCore.CliForegroundColor.Yellow)}     ${input}`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("Version:", cliCore.CliForegroundColor.Yellow)}   ${isNil ? "nil" : version !== null ? `v${version}` : "unknown"}`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("Variant:", cliCore.CliForegroundColor.Yellow)}   ${variant}`
+          );
+          writer.writeln();
+          writer.writeln(
+            `  ${writer.wrapInColor("Formats:", cliCore.CliForegroundColor.Yellow)}`
+          );
+          for (const fmt of GUID_FORMATS) {
+            const formatted = formatGUID(lower, fmt);
+            writer.writeln(
+              `    ${writer.wrapInColor(fmt.padEnd(14), cliCore.CliForegroundColor.Cyan)} ${formatted}`
+            );
+          }
+          context.process.output({
+            input,
+            version,
+            variant,
+            isNil,
+            formats: Object.fromEntries(
+              GUID_FORMATS.map((fmt) => [
+                fmt,
+                formatGUID(lower, fmt)
+              ])
+            )
+          });
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Display version, variant, and all format representations of a UUID"
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("guid inspect <uuid>", cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      // --- nil ---
+      {
+        command: "nil",
+        aliases: ["empty", "zero"],
+        description: "Output the nil UUID (all zeros)",
+        parameters: [
+          {
+            name: "copy",
+            aliases: ["c"],
+            description: "Copy to clipboard",
+            required: false,
+            type: "boolean"
+          }
+        ],
+        processCommand: async (_, context) => {
+          context.writer.writeln(NIL_GUID);
+          if (_.args["copy"] || _.args["c"]) {
+            await context.clipboard.write(NIL_GUID);
+            context.writer.writeInfo("Copied to clipboard");
+          }
+          context.process.output(NIL_GUID);
+        }
+      },
+      // --- compare ---
+      {
+        command: "compare",
+        aliases: ["eq", "equals"],
+        description: "Check if two UUIDs are equal (case/format insensitive)",
+        acceptsRawInput: true,
+        processCommand: async (command, context) => {
+          const raw = (command.value || "").trim();
+          const parts = raw.split(/\s+/);
+          if (parts.length !== 2) {
+            context.writer.writeError(
+              "Provide exactly two UUIDs to compare"
+            );
+            context.writer.writeln();
+            context.writer.writeln(
+              `  Usage: ${context.writer.wrapInColor("guid compare <uuid1> <uuid2>", cliCore.CliForegroundColor.Cyan)}`
+            );
+            return;
+          }
+          const [a, b] = parts;
+          const cleanA = a.replace(/[-{}()urn:uuid ]/g, "").toLowerCase();
+          const cleanB = b.replace(/[-{}()urn:uuid ]/g, "").toLowerCase();
+          if (!/^[0-9a-f]{32}$/.test(cleanA) || !/^[0-9a-f]{32}$/.test(cleanB)) {
+            context.writer.writeError(
+              "One or both inputs are not valid UUIDs"
+            );
+            return;
+          }
+          const equal = cleanA === cleanB;
+          if (equal) {
+            context.writer.writeSuccess("The UUIDs are equal");
+          } else {
+            context.writer.writeError("The UUIDs are different");
+          }
+          context.process.output({ equal, a, b });
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Compare two UUIDs for equality regardless of case or format"
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4CB} Usage:");
+          writer.writeln(
+            `  ${writer.wrapInColor("guid compare <uuid1> <uuid2>", cliCore.CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln("\u{1F4DD} Examples:");
+          writer.writeln(
+            `  guid compare 550e8400-e29b-41d4-a716-446655440000 550E8400-E29B-41D4-A716-446655440000`
+          );
+          writer.writeln(
+            `  ${writer.wrapInColor("\u2192 The UUIDs are equal", cliCore.CliForegroundColor.Green)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    await context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer } = context;
+    writer.writeln(this.description);
+    writer.writeln();
+    writer.writeln("\u{1F4CB} Commands:");
+    writer.writeln(
+      `  ${writer.wrapInColor("guid new", cliCore.CliForegroundColor.Cyan)}                           Generate UUIDs`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("guid validate <uuid>", cliCore.CliForegroundColor.Cyan)}               Validate and detect version`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("guid format <uuid> --to=<fmt>", cliCore.CliForegroundColor.Cyan)}      Convert format`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("guid inspect <uuid>", cliCore.CliForegroundColor.Cyan)}                Show detailed info`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("guid compare <a> <b>", cliCore.CliForegroundColor.Cyan)}               Compare two UUIDs`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("guid nil", cliCore.CliForegroundColor.Cyan)}                           Output nil UUID`
+    );
+    writer.writeln();
+    writer.writeln("\u{1F4DD} Examples:");
+    writer.writeln(
+      `  guid new --count=5 --copy                        ${writer.wrapInColor("# 5 UUIDs, copied", cliCore.CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  guid new --format=uppercase                      ${writer.wrapInColor("# A1B2C3D4-...", cliCore.CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  guid validate 550e8400-e29b-41d4-a716-446655440000  ${writer.wrapInColor("# Valid UUID (v4)", cliCore.CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  guid inspect 550e8400-e29b-41d4-a716-446655440000   ${writer.wrapInColor("# Version, variant, formats", cliCore.CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  guid format <uuid> --to=urn                      ${writer.wrapInColor("# urn:uuid:...", cliCore.CliForegroundColor.Green)}`
+    );
+  }
+};
+
+// src/public-api.ts
+var guidModule = {
+  apiVersion: API_VERSION,
+  name: "@qodalis/cli-guid",
+  processors: [new CliGuidCommandProcessor()],
+  translations: {
+    es: { "cli.guid.description": "Generar, validar, formatear e inspeccionar UUIDs" },
+    fr: { "cli.guid.description": "G\xE9n\xE9rer, valider, formater et inspecter des UUIDs" },
+    de: { "cli.guid.description": "UUIDs generieren, validieren, formatieren und inspizieren" },
+    pt: { "cli.guid.description": "Gerar, validar, formatar e inspecionar UUIDs" },
+    it: { "cli.guid.description": "Generare, validare, formattare e ispezionare UUID" },
+    ja: { "cli.guid.description": "UUID\u306E\u751F\u6210\u3001\u691C\u8A3C\u3001\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u3001\u691C\u67FB" },
+    ko: { "cli.guid.description": "UUID \uC0DD\uC131, \uAC80\uC99D, \uD3EC\uB9F7 \uBC0F \uAC80\uC0AC" },
+    zh: { "cli.guid.description": "\u751F\u6210\u3001\u9A8C\u8BC1\u3001\u683C\u5F0F\u5316\u548C\u68C0\u67E5 UUID" },
+    ru: { "cli.guid.description": "\u0413\u0435\u043D\u0435\u0440\u0430\u0446\u0438\u044F, \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0430, \u0444\u043E\u0440\u043C\u0430\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0435 \u0438 \u0430\u043D\u0430\u043B\u0438\u0437 UUID" },
+    ro: { "cli.guid.description": "Generare, validare, formatare \u0219i inspectare UUID-uri" }
+  }
+};
+
+exports.CliGuidCommandProcessor = CliGuidCommandProcessor;
+exports.NIL_GUID = NIL_GUID;
+exports.detectGUIDVersion = detectGUIDVersion;
+exports.formatGUID = formatGUID;
+exports.generateGUID = generateGUID;
+exports.guidModule = guidModule;
+exports.validateAnyGUID = validateAnyGUID;
+exports.validateGUID = validateGUID;
+//# sourceMappingURL=public-api.js.map
+//# sourceMappingURL=public-api.js.map