@digitaldefiance/node-ecies-lib 4.12.8 → 4.13.0

package/src/lib/guid.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Guid = void 0;
+exports.GuidBuffer = void 0;
 const tslib_1 = require("tslib");
+/**
+ * RFC 4122 compliant GUID implementation for Node.js.
+ * Provides comprehensive GUID/UUID operations including generation (v1, v3, v4, v5),
+ * validation, conversion between formats (hex, base64, bigint, Buffer), and type-safe
+ * branded types for compile-time format verification.
+ */
 const ecies_lib_1 = require("@digitaldefiance/ecies-lib");
 const uuid = tslib_1.__importStar(require("uuid"));
 /**
@@ -14,7 +20,7 @@ const uuid = tslib_1.__importStar(require("uuid"));
  * - RawGuidPlatformBuffer: A 16-byte Buffer representation of the GUID
  * Guid instances can be converted to any of these representations using the appropriate method.
  */
-class Guid {
+class GuidBuffer {
     /**
      * GUID is stored internally as a raw 16-byte Buffer.
      */
@@ -44,6 +50,10 @@ class Guid {
      * Cached base64 representation for performance
      */
     _cachedBase64;
+    /**
+     * The RFC 4122 version of this GUID (1, 3, 4, 5, or undefined for boundary/invalid)
+     */
+    __version;
     /**
      * Regex for validating hex strings (case insensitive)
      */
@@ -72,13 +82,13 @@ class Guid {
      * Empty/nil GUID constant (all zeros)
      */
     static get Empty() {
-        if (!Guid._empty) {
-            Guid._empty = Object.freeze(new Guid('00000000-0000-0000-0000-000000000000'));
+        if (!GuidBuffer._empty) {
+            GuidBuffer._empty = Object.freeze(new GuidBuffer('00000000-0000-0000-0000-000000000000'));
         }
-        return Guid._empty;
+        return GuidBuffer._empty;
     }
     constructor(value) {
-        const buffer = Guid.validateAndConvert(value);
+        const buffer = GuidBuffer.validateAndConvert(value);
         // Note: We cannot freeze a Buffer as it's an ArrayBuffer view
         // Instead, we ensure the buffer is never directly modified after construction
         this._value = buffer;
@@ -86,6 +96,7 @@ class Guid {
         this._cachedFullHex = undefined;
         this._cachedShortHex = undefined;
         this._cachedBase64 = undefined;
+        this.__version = undefined;
         // Seal the instance to prevent property addition/deletion
         // Cache properties can still be set once since they were initialized
         Object.seal(this);
@@ -116,18 +127,18 @@ class Guid {
             if (typeof value === 'string') {
                 const isFullHex = value.length === 36 && value.includes('-');
                 const isShortHex = value.length === 32 && !value.includes('-');
-                if (isFullHex && !Guid.FULL_HEX_PATTERN.test(value)) {
+                if (isFullHex && !GuidBuffer.FULL_HEX_PATTERN.test(value)) {
                     const buffer = Buffer.from(value);
                     throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidWithDetails, ecies_lib_1.GuidBrandType.FullHexGuid, value.length, buffer);
                 }
-                else if (isShortHex && !Guid.HEX_PATTERN.test(value)) {
+                else if (isShortHex && !GuidBuffer.HEX_PATTERN.test(value)) {
                     const buffer = Buffer.from(value);
                     throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidWithDetails, ecies_lib_1.GuidBrandType.ShortHexGuid, value.length, buffer);
                 }
             }
             // Determine and verify the brand/type
-            const expectedBrand = Guid.whichBrand(value);
-            const verifiedBrand = Guid.verifyGuid(expectedBrand, value);
+            const expectedBrand = GuidBuffer.whichBrand(value);
+            const verifiedBrand = GuidBuffer.verifyGuid(expectedBrand, value);
             if (!verifiedBrand) {
                 const valueBuffer = Buffer.isBuffer(value)
                     ? value
@@ -135,11 +146,11 @@ class Guid {
                 throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidWithDetails, expectedBrand, undefined, valueBuffer);
             }
             // Convert to raw buffer
-            const buffer = Guid.toRawGuidPlatformBuffer(value);
+            const buffer = GuidBuffer.toRawGuidPlatformBuffer(value);
             // Validate against UUID standard (skip for boundary values)
             const hexString = buffer.toString('hex');
-            const fullHex = Guid.toFullHexGuid(hexString);
-            const isBoundary = Guid.isBoundaryValue(fullHex);
+            const fullHex = GuidBuffer.toFullHexGuid(hexString);
+            const isBoundary = GuidBuffer.isBoundaryValue(fullHex);
             if (!isBoundary && !uuid.validate(fullHex)) {
                 throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid, expectedBrand, undefined, buffer);
             }
@@ -167,7 +178,7 @@ class Guid {
         return this.asBase64Guid;
     }
     static hydrate(value) {
-        return new Guid(value);
+        return GuidBuffer.withVersion(new GuidBuffer(value));
     }
     static LengthMap = {
         [ecies_lib_1.GuidBrandType.Unknown]: -1,
@@ -210,6 +221,16 @@ class Guid {
     get asRawGuidPlatformBufferUnsafe() {
         return this._value;
     }
+    /**
+     * Attaches the RFC 4122 version to a GuidBuffer instance.
+     * @param guid The GuidBuffer instance to attach version to
+     * @returns The same instance with __version property set
+     */
+    static withVersion(guid) {
+        const version = guid.getVersion();
+        guid.__version = version;
+        return guid;
+    }
     /**
      * Generates a new random v4 GUID.
      * @returns A new Guid instance with a randomly generated value
@@ -220,7 +241,7 @@ class Guid {
             if (!uuidStr) {
                 throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
             }
-            return new Guid(uuidStr);
+            return GuidBuffer.withVersion(new GuidBuffer(uuidStr));
         }
         catch (error) {
             if (error instanceof ecies_lib_1.GuidError) {
@@ -234,34 +255,34 @@ class Guid {
      * @returns A new Guid instance with a randomly generated v4 value
      */
     static v4() {
-        return Guid.generate();
+        return GuidBuffer.generate();
     }
     /**
      * Alias for generate() for backward compatibility.
      * @deprecated Use generate() instead for clearer intent
      */
     static new() {
-        return Guid.generate();
+        return GuidBuffer.generate();
     }
     /**
      * Parses a GUID from any valid format, throwing on invalid input.
      * This is the primary parsing method for when you expect valid input.
      * @param value The value to parse
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      * @throws {GuidError} If the value is not a valid GUID
      */
     static parse(value) {
-        return new Guid(value);
+        return GuidBuffer.withVersion(new GuidBuffer(value));
     }
     /**
      * Attempts to parse a GUID, returning null on failure instead of throwing.
      * Use this when you're uncertain if the input is valid.
      * @param value The value to parse
-     * @returns A new Guid instance or null if parsing fails
+     * @returns A new Guid instance with __version attached, or null if parsing fails
      */
     static tryParse(value) {
         try {
-            return new Guid(value);
+            return GuidBuffer.withVersion(new GuidBuffer(value));
         }
         catch {
             return null;
@@ -277,7 +298,7 @@ class Guid {
         if (!value)
             return false;
         try {
-            const guid = new Guid(value);
+            const guid = new GuidBuffer(value);
             return guid.isValidV4();
         }
         catch {
@@ -287,68 +308,68 @@ class Guid {
     /**
      * Factory method to create a GUID from a full hex string.
      * @param fullHex The full hex string (with dashes)
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      */
     static fromFullHex(fullHex) {
-        return new Guid(fullHex);
+        return GuidBuffer.withVersion(new GuidBuffer(fullHex));
     }
     /**
      * Factory method to create a GUID from a short hex string.
      * @param shortHex The short hex string (without dashes)
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      */
     static fromShortHex(shortHex) {
-        return new Guid(shortHex);
+        return GuidBuffer.withVersion(new GuidBuffer(shortHex));
     }
     /**
      * Factory method to create a GUID from a base64 string.
      * @param base64 The base64 encoded string
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      */
     static fromBase64(base64) {
-        return new Guid(base64);
+        return GuidBuffer.withVersion(new GuidBuffer(base64));
     }
     /**
      * Factory method to create a GUID from a bigint.
      * @param bigint The bigint value
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      */
     static fromBigInt(bigint) {
-        return new Guid(bigint);
+        return GuidBuffer.withVersion(new GuidBuffer(bigint));
     }
     /**
      * Factory method to create a GUID from a raw buffer.
      * @param buffer The raw 16-byte buffer
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      */
     static fromBuffer(buffer) {
-        return new Guid(buffer);
+        return GuidBuffer.withVersion(new GuidBuffer(buffer));
     }
     /**
      * Factory method to create a GUID from a raw Uint8Array.
      * This converts the Uint8Array to a Buffer first.
      * @param bytes The raw 16-byte Uint8Array
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      */
     static fromUint8Array(bytes) {
-        return new Guid(Buffer.from(bytes));
+        return GuidBuffer.withVersion(new GuidBuffer(Buffer.from(bytes)));
     }
     /**
      * Creates a namespace-based v3 GUID (MD5 hash).
      * Use this for deterministic GUIDs based on a namespace and name.
      * @param namespace The namespace GUID (e.g., uuid.v3.DNS)
      * @param name The name to hash within the namespace
-     * @returns A new Guid instance containing the v3 GUID
+     * @returns A new Guid instance containing the v3 GUID with __version attached
      * @example
      * const guid = Guid.v3('example.com', uuid.v3.DNS);
      */
     static v3(name, namespace) {
         try {
             const namespaceStr = Buffer.isBuffer(namespace)
-                ? Guid.toFullHexGuid(namespace.toString('hex'))
+                ? GuidBuffer.toFullHexGuid(namespace.toString('hex'))
                 : namespace;
             const v3Guid = uuid.v3(name, namespaceStr);
-            return new Guid(v3Guid);
+            return GuidBuffer.withVersion(new GuidBuffer(v3Guid));
         }
         catch (error) {
             if (error instanceof ecies_lib_1.GuidError) {
@@ -363,17 +384,17 @@ class Guid {
      * Preferred over v3 as SHA-1 is stronger than MD5.
      * @param namespace The namespace GUID (e.g., uuid.v5.DNS)
      * @param name The name to hash within the namespace
-     * @returns A new Guid instance containing the v5 GUID
+     * @returns A new Guid instance containing the v5 GUID with __version attached
      * @example
      * const guid = Guid.v5('example.com', uuid.v5.DNS);
      */
     static v5(name, namespace) {
         try {
             const namespaceStr = Buffer.isBuffer(namespace)
-                ? Guid.toFullHexGuid(namespace.toString('hex'))
+                ? GuidBuffer.toFullHexGuid(namespace.toString('hex'))
                 : namespace;
             const v5Guid = uuid.v5(name, namespaceStr);
-            return new Guid(v5Guid);
+            return GuidBuffer.withVersion(new GuidBuffer(v5Guid));
         }
         catch (error) {
             if (error instanceof ecies_lib_1.GuidError) {
@@ -400,7 +421,7 @@ class Guid {
     get asFullHexGuid() {
         if (!this._cachedFullHex) {
             const hexString = this._value.toString('hex');
-            this._cachedFullHex = Guid.toFullHexGuid(hexString);
+            this._cachedFullHex = GuidBuffer.toFullHexGuid(hexString);
         }
         return this._cachedFullHex;
     }
@@ -422,7 +443,7 @@ class Guid {
      */
     get asShortHexGuid() {
         if (!this._cachedShortHex) {
-            this._cachedShortHex = Guid.toShortHexGuid(this.asFullHexGuid);
+            this._cachedShortHex = GuidBuffer.toShortHexGuid(this.asFullHexGuid);
         }
         return this._cachedShortHex;
     }
@@ -464,10 +485,10 @@ class Guid {
      * @returns True if the value is a boundary value.
      */
     static isBoundaryValue(value) {
-        return (value === Guid.BOUNDARY_VALUES.ALL_ZEROS_FULL ||
-            value === Guid.BOUNDARY_VALUES.ALL_ZEROS_SHORT ||
-            value === Guid.BOUNDARY_VALUES.ALL_FS_FULL ||
-            value === Guid.BOUNDARY_VALUES.ALL_FS_SHORT);
+        return (value === GuidBuffer.BOUNDARY_VALUES.ALL_ZEROS_FULL ||
+            value === GuidBuffer.BOUNDARY_VALUES.ALL_ZEROS_SHORT ||
+            value === GuidBuffer.BOUNDARY_VALUES.ALL_FS_FULL ||
+            value === GuidBuffer.BOUNDARY_VALUES.ALL_FS_SHORT);
     }
     /**
      * Verifies if a given GUID is valid for the given brand.
@@ -480,7 +501,7 @@ class Guid {
             return false;
         }
         try {
-            const verifyFunc = Guid.VerifyFunctions[guidBrand];
+            const verifyFunc = GuidBuffer.VerifyFunctions[guidBrand];
             return verifyFunc(guid);
         }
         catch {
@@ -493,7 +514,7 @@ class Guid {
      * @returns The length of the GUID for the given brand.
      */
     static guidBrandToLength(guidBrand) {
-        const length = Guid.LengthMap[guidBrand];
+        const length = GuidBuffer.LengthMap[guidBrand];
         if (length <= 0) {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownBrand, guidBrand);
         }
@@ -509,7 +530,7 @@ class Guid {
         if (length <= 0) {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
         }
-        const brand = Guid.ReverseLengthMap[length];
+        const brand = GuidBuffer.ReverseLengthMap[length];
         if (!brand || brand === ecies_lib_1.GuidBrandType.Unknown) {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
         }
@@ -530,16 +551,16 @@ class Guid {
             if (fullHexGuidValue === null || fullHexGuidValue === undefined) {
                 return false;
             }
-            const expectedLength = Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid);
+            const expectedLength = GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid);
             const strValue = String(fullHexGuidValue);
             if (strValue.length !== expectedLength) {
                 return false;
             }
             // Boundary values are always valid
-            if (Guid.isBoundaryValue(strValue)) {
+            if (GuidBuffer.isBoundaryValue(strValue)) {
                 return true;
             }
-            return Guid.validateUuid(strValue);
+            return GuidBuffer.validateUuid(strValue);
         }
         catch {
             return false;
@@ -555,15 +576,15 @@ class Guid {
             if (shortHexGuidValue === null || shortHexGuidValue === undefined) {
                 return false;
             }
-            const expectedLength = Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid);
+            const expectedLength = GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid);
             const strValue = String(shortHexGuidValue);
             if (strValue.length !== expectedLength) {
                 return false;
             }
             try {
-                const fullHexGuid = Guid.toFullHexGuid(strValue);
+                const fullHexGuid = GuidBuffer.toFullHexGuid(strValue);
                 // Boundary values are always valid
-                if (Guid.isBoundaryValue(fullHexGuid)) {
+                if (GuidBuffer.isBoundaryValue(fullHexGuid)) {
                     return true;
                 }
                 return uuid.validate(fullHexGuid);
@@ -590,20 +611,20 @@ class Guid {
             if (typeof value === 'bigint') {
                 valueLength = value.toString(16).length;
             }
-            else if (Guid.isBufferLike(value)) {
+            else if (GuidBuffer.isBufferLike(value)) {
                 valueLength = value.length;
             }
             else {
                 valueLength = String(value).length;
             }
-            const result = valueLength === Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid);
+            const result = valueLength === GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid);
             if (result) {
                 try {
-                    const fromBase64 = Guid.toRawGuidPlatformBuffer(value);
+                    const fromBase64 = GuidBuffer.toRawGuidPlatformBuffer(value);
                     const hexString = fromBase64.toString('hex');
-                    const fullHexGuid = Guid.toFullHexGuid(hexString);
+                    const fullHexGuid = GuidBuffer.toFullHexGuid(hexString);
                     // Boundary values are always valid
-                    if (Guid.isBoundaryValue(fullHexGuid)) {
+                    if (GuidBuffer.isBoundaryValue(fullHexGuid)) {
                         return true;
                     }
                     return uuid.validate(fullHexGuid);
@@ -628,12 +649,12 @@ class Guid {
             if (value === null || value === undefined) {
                 return false;
             }
-            const expectedLength = Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer);
+            const expectedLength = GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer);
             let valueLength;
             if (typeof value === 'bigint') {
                 valueLength = value.toString(16).length;
             }
-            else if (Guid.isBufferLike(value)) {
+            else if (GuidBuffer.isBufferLike(value)) {
                 valueLength = value.length;
             }
             else {
@@ -643,18 +664,18 @@ class Guid {
                 return false;
             }
             try {
-                if (!Guid.isBufferLike(value)) {
+                if (!GuidBuffer.isBufferLike(value)) {
                     return false;
                 }
                 // Convert Uint8Array to Buffer if needed
                 const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value);
                 const hexString = buffer.toString('hex');
-                const fullHexGuid = Guid.toFullHexGuid(hexString);
+                const fullHexGuid = GuidBuffer.toFullHexGuid(hexString);
                 // Boundary values are always valid
-                if (Guid.isBoundaryValue(fullHexGuid)) {
+                if (GuidBuffer.isBoundaryValue(fullHexGuid)) {
                     return true;
                 }
-                return Guid.validateUuid(fullHexGuid);
+                return GuidBuffer.validateUuid(fullHexGuid);
             }
             catch {
                 return false;
@@ -677,13 +698,13 @@ class Guid {
             if (typeof value !== 'bigint') {
                 return false;
             }
-            if (value < 0n || value > Guid.MAX_BIGINT_VALUE) {
+            if (value < 0n || value > GuidBuffer.MAX_BIGINT_VALUE) {
                 return false;
             }
             try {
-                const fromBigInt = Guid.toFullHexFromBigInt(value);
+                const fromBigInt = GuidBuffer.toFullHexFromBigInt(value);
                 // Boundary values are always valid
-                if (Guid.isBoundaryValue(fromBigInt)) {
+                if (GuidBuffer.isBoundaryValue(fromBigInt)) {
                     return true;
                 }
                 return uuid.validate(fromBigInt);
@@ -708,11 +729,11 @@ class Guid {
         if (typeof value === 'bigint') {
             return ecies_lib_1.GuidBrandType.BigIntGuid;
         }
-        const isBuffer = Guid.isBufferLike(value);
+        const isBuffer = GuidBuffer.isBufferLike(value);
         const expectedLength = isBuffer
             ? value.length
             : String(value).length;
-        return Guid.lengthToGuidBrand(expectedLength, isBuffer);
+        return GuidBuffer.lengthToGuidBrand(expectedLength, isBuffer);
     }
     /**
      * Converts a given short hex GUID to a full hex GUID.
@@ -734,32 +755,34 @@ class Guid {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
         }
         if (typeof guid === 'bigint') {
-            return Guid.toFullHexFromBigInt(guid);
+            return GuidBuffer.toFullHexFromBigInt(guid);
         }
-        else if (Guid.isBufferLike(guid) &&
+        else if (GuidBuffer.isBufferLike(guid) &&
             guid.length ===
-                Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
+                GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
             const hexString = guid.toString('hex');
             const shortHex = hexString;
-            return Guid.shortGuidToFullGuid(shortHex);
+            return GuidBuffer.shortGuidToFullGuid(shortHex);
         }
-        else if (Guid.isBufferLike(guid)) {
+        else if (GuidBuffer.isBufferLike(guid)) {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
         }
         // all remaining cases are string types
         const strValue = String(guid);
-        if (strValue.length === Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid)) {
+        if (strValue.length ===
+            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid)) {
             // short hex guid
-            return Guid.shortGuidToFullGuid(strValue);
+            return GuidBuffer.shortGuidToFullGuid(strValue);
         }
-        else if (strValue.length === Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid)) {
+        else if (strValue.length ===
+            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid)) {
             // already a full hex guid
             return strValue;
         }
-        else if (strValue.length === Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid)) {
+        else if (strValue.length === GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid)) {
             // base64 guid
             const shortGuid = Buffer.from(strValue, 'base64').toString('hex');
-            return Guid.shortGuidToFullGuid(shortGuid);
+            return GuidBuffer.shortGuidToFullGuid(shortGuid);
         }
         else {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
@@ -770,28 +793,30 @@ class Guid {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
         }
         if (typeof guid === 'bigint') {
-            const fullHex = Guid.toFullHexFromBigInt(guid);
+            const fullHex = GuidBuffer.toFullHexFromBigInt(guid);
             return fullHex.replace(/-/g, '');
         }
-        else if (Guid.isBufferLike(guid) &&
+        else if (GuidBuffer.isBufferLike(guid) &&
             guid.length ===
-                Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
+                GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
             return guid.toString('hex');
         }
-        else if (Guid.isBufferLike(guid)) {
+        else if (GuidBuffer.isBufferLike(guid)) {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
         }
         // all remaining cases are string types
         const strValue = String(guid);
-        if (strValue.length === Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid)) {
+        if (strValue.length ===
+            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid)) {
             // already a short hex guid
             return strValue;
         }
-        else if (strValue.length === Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid)) {
+        else if (strValue.length ===
+            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid)) {
             // full hex guid
             return strValue.replace(/-/g, '');
         }
-        else if (strValue.length === Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid)) {
+        else if (strValue.length === GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid)) {
             // base64 guid
             return Buffer.from(strValue, 'base64').toString('hex');
         }
@@ -805,7 +830,7 @@ class Guid {
      * @returns The bigint as a full hex GUID.
      */
     static toFullHexFromBigInt(bigInt) {
-        if (bigInt < 0n || bigInt > Guid.MAX_BIGINT_VALUE) {
+        if (bigInt < 0n || bigInt > GuidBuffer.MAX_BIGINT_VALUE) {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
         }
         const uuidBigInt = bigInt.toString(16).padStart(32, '0');
@@ -830,14 +855,14 @@ class Guid {
      * @returns The GUID value as a raw GUID buffer.
      */
     static toRawGuidPlatformBuffer(value) {
-        const expectedBrand = Guid.whichBrand(value);
+        const expectedBrand = GuidBuffer.whichBrand(value);
         let rawGuidBufferResult = Buffer.alloc(0);
         switch (expectedBrand) {
             case ecies_lib_1.GuidBrandType.FullHexGuid:
-                rawGuidBufferResult = Buffer.from(Guid.toShortHexGuid(value), 'hex');
+                rawGuidBufferResult = Buffer.from(GuidBuffer.toShortHexGuid(value), 'hex');
                 break;
             case ecies_lib_1.GuidBrandType.ShortHexGuid:
-                rawGuidBufferResult = Buffer.from(Guid.toShortHexGuid(value), 'hex');
+                rawGuidBufferResult = Buffer.from(GuidBuffer.toShortHexGuid(value), 'hex');
                 break;
             case ecies_lib_1.GuidBrandType.Base64Guid:
                 // Ensure value is a string before using it with Buffer.from
@@ -861,13 +886,13 @@ class Guid {
                 }
                 break;
             case ecies_lib_1.GuidBrandType.BigIntGuid:
-                rawGuidBufferResult = Buffer.from(Guid.toShortHexGuid(Guid.toFullHexFromBigInt(value)), 'hex');
+                rawGuidBufferResult = Buffer.from(GuidBuffer.toShortHexGuid(GuidBuffer.toFullHexFromBigInt(value)), 'hex');
                 break;
             default:
                 throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownBrand);
         }
         if (rawGuidBufferResult.length !==
-            Guid.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
+            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
             throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownLength, undefined, rawGuidBufferResult.length);
         }
         return rawGuidBufferResult;
@@ -914,14 +939,14 @@ class Guid {
      * @returns True if the GUID is null, undefined, or empty
      */
     static isNilOrEmpty(guid) {
-        return !guid || (guid instanceof Guid && guid.isEmpty());
+        return !guid || (guid instanceof GuidBuffer && guid.isEmpty());
     }
     /**
      * Creates a new Guid instance with the same value as this one.
-     * @returns A new Guid instance with identical value
+     * @returns A new Guid instance with identical value and __version attached
      */
     clone() {
-        return new Guid(Buffer.from(this._value));
+        return GuidBuffer.withVersion(new GuidBuffer(Buffer.from(this._value)));
     }
     /**
      * Returns the hash code for this GUID based on its buffer content.
@@ -943,7 +968,7 @@ class Guid {
      */
     getVersion() {
         // Skip boundary values
-        if (Guid.isBoundaryValue(this.asFullHexGuid)) {
+        if (GuidBuffer.isBoundaryValue(this.asFullHexGuid)) {
             return undefined;
         }
         // Version is in bits 48-51 (byte 6, high nibble)
@@ -966,7 +991,7 @@ class Guid {
      */
     isValidV4() {
         // Boundary values are considered valid
-        if (Guid.isBoundaryValue(this.asFullHexGuid)) {
+        if (GuidBuffer.isBoundaryValue(this.asFullHexGuid)) {
             return true;
         }
         const version = this.getVersion();
@@ -1029,12 +1054,12 @@ class Guid {
     }
     /**
      * Creates a v1 GUID (time-based).
-     * @returns A new Guid instance containing a v1 GUID
+     * @returns A new Guid instance containing a v1 GUID with __version attached
      */
     static v1() {
         try {
             const v1Guid = uuid.v1();
-            return new Guid(v1Guid);
+            return GuidBuffer.withVersion(new GuidBuffer(v1Guid));
         }
         catch (error) {
             if (error instanceof ecies_lib_1.GuidError)
@@ -1061,22 +1086,23 @@ class Guid {
     }
     /**
      * Creates a GUID from URL-safe base64.
+     * @returns A new Guid instance with __version attached
      */
     static fromUrlSafeBase64(urlSafe) {
         const base64 = urlSafe
             .replace(/-/g, '+')
             .replace(/_/g, '/')
             .padEnd(24, '=');
-        return new Guid(base64);
+        return GuidBuffer.withVersion(new GuidBuffer(base64));
     }
     /**
      * Alias for isRawGuidPlatformBuffer for backward compatibility
      */
-    static isRawGuidBuffer = Guid.isRawGuidPlatformBuffer;
+    static isRawGuidBuffer = GuidBuffer.isRawGuidPlatformBuffer;
     /**
      * Alias for toRawGuidPlatformBuffer for backward compatibility
      */
-    static toRawGuidBuffer = Guid.toRawGuidPlatformBuffer;
+    static toRawGuidBuffer = GuidBuffer.toRawGuidPlatformBuffer;
 }
-exports.Guid = Guid;
+exports.GuidBuffer = GuidBuffer;
 //# sourceMappingURL=guid.js.map