@digitaldefiance/ecies-lib 4.12.8 → 4.13.0

package/src/lib/guid.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Guid = void 0;
+exports.GuidUint8Array = void 0;
 const tslib_1 = require("tslib");
 const uuid = tslib_1.__importStar(require("uuid"));
 const guid_brand_type_1 = require("../enumerations/guid-brand-type");
@@ -17,7 +17,7 @@ const guid_1 = require("../errors/guid");
  * - RawGuidUint8Array: A 16-byte Uint8Array representation of the GUID
  * Guid instances can be converted to any of these representations using the appropriate method.
  */
-class Guid {
+class GuidUint8Array {
     /**
      * GUID is stored internally as a raw 16-byte Uint8Array.
      */
@@ -47,6 +47,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)
      */
@@ -69,13 +73,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 (!GuidUint8Array._empty) {
+            GuidUint8Array._empty = Object.freeze(new GuidUint8Array('00000000-0000-0000-0000-000000000000'));
         }
-        return Guid._empty;
+        return GuidUint8Array._empty;
     }
     constructor(value) {
-        const array = Guid.validateAndConvert(value);
+        const array = GuidUint8Array.validateAndConvert(value);
         // Note: We cannot freeze a Buffer as it's an ArrayBuffer view
         // Instead, we ensure the array is never directly modified after construction
         this._value = array;
@@ -83,6 +87,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);
@@ -113,32 +118,32 @@ 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 && !GuidUint8Array.FULL_HEX_PATTERN.test(value)) {
                     const array = new TextEncoder().encode(value);
                     throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidWithDetails, guid_brand_type_1.GuidBrandType.FullHexGuid, value.length, array);
                 }
-                else if (isShortHex && !Guid.HEX_PATTERN.test(value)) {
+                else if (isShortHex && !GuidUint8Array.HEX_PATTERN.test(value)) {
                     const array = new TextEncoder().encode(value);
                     throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidWithDetails, guid_brand_type_1.GuidBrandType.ShortHexGuid, value.length, array);
                 }
             }
             // Determine and verify the brand/type
-            const expectedBrand = Guid.whichBrand(value);
-            const verifiedBrand = Guid.verifyGuid(expectedBrand, value);
+            const expectedBrand = GuidUint8Array.whichBrand(value);
+            const verifiedBrand = GuidUint8Array.verifyGuid(expectedBrand, value);
             if (!verifiedBrand) {
-                const valueBuffer = Guid.isUint8Array(value)
+                const valueBuffer = GuidUint8Array.isUint8Array(value)
                     ? value
                     : new TextEncoder().encode(strValue);
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidWithDetails, expectedBrand, undefined, valueBuffer);
             }
             // Convert to raw array
-            const array = Guid.toRawGuidPlatformBuffer(value);
+            const array = GuidUint8Array.toRawGuidPlatformBuffer(value);
             // Validate against UUID standard (skip for boundary values)
             const hexString = Array.from(array)
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join('');
-            const fullHex = Guid.toFullHexGuid(hexString);
-            const isBoundary = Guid.isBoundaryValue(fullHex);
+            const fullHex = GuidUint8Array.toFullHexGuid(hexString);
+            const isBoundary = GuidUint8Array.isBoundaryValue(fullHex);
             if (!isBoundary && !uuid.validate(fullHex)) {
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid, expectedBrand, undefined, array);
             }
@@ -153,7 +158,7 @@ class Guid {
             if (typeof value === 'bigint') {
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
             }
-            const length = Guid.isUint8Array(value)
+            const length = GuidUint8Array.isUint8Array(value)
                 ? value.length
                 : String(value).length;
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
@@ -166,7 +171,7 @@ class Guid {
         return this.asBase64Guid;
     }
     static hydrate(value) {
-        return new Guid(value);
+        return GuidUint8Array.withVersion(new GuidUint8Array(value));
     }
     static LengthMap = {
         [guid_brand_type_1.GuidBrandType.Unknown]: -1,
@@ -209,6 +214,16 @@ class Guid {
     get asRawGuidPlatformBufferUnsafe() {
         return this._value;
     }
+    /**
+     * Attaches the RFC 4122 version to a GuidUint8Array instance.
+     * @param guid The GuidUint8Array 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
@@ -219,7 +234,7 @@ class Guid {
             if (!uuidStr) {
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
             }
-            return new Guid(uuidStr);
+            return GuidUint8Array.withVersion(new GuidUint8Array(uuidStr));
         }
         catch (error) {
             if (error instanceof guid_1.GuidError) {
@@ -233,34 +248,34 @@ class Guid {
      * @returns A new Guid instance with a randomly generated v4 value
      */
     static v4() {
-        return Guid.generate();
+        return GuidUint8Array.generate();
     }
     /**
      * Alias for generate() for backward compatibility.
      * @deprecated Use generate() instead for clearer intent
      */
     static new() {
-        return Guid.generate();
+        return GuidUint8Array.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 GuidUint8Array.withVersion(new GuidUint8Array(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 GuidUint8Array.withVersion(new GuidUint8Array(value));
         }
         catch {
             return null;
@@ -276,7 +291,7 @@ class Guid {
         if (!value)
             return false;
         try {
-            const guid = new Guid(value);
+            const guid = new GuidUint8Array(value);
             return guid.isValidV4();
         }
         catch {
@@ -286,51 +301,51 @@ 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 GuidUint8Array.withVersion(new GuidUint8Array(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 GuidUint8Array.withVersion(new GuidUint8Array(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 GuidUint8Array.withVersion(new GuidUint8Array(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 GuidUint8Array.withVersion(new GuidUint8Array(bigint));
     }
     /**
      * Factory method to create a GUID from a raw Uint8Array.
      * This is an explicit alias for fromBuffer(), provided for clarity when working
      * with browser environments where Uint8Array is the native binary type.
      * @param bytes The raw 16-byte Uint8Array
-     * @returns A new Guid instance
+     * @returns A new Guid instance with __version attached
      */
     static fromPlatformBuffer(bytes) {
-        return new Guid(bytes);
+        return GuidUint8Array.withVersion(new GuidUint8Array(bytes));
     }
     /**
      * Creates a namespace-based v3 GUID (MD5 hash).
      * Use this for deterministic GUIDs based on a namespace and name.
      * @param name The name to hash within the namespace
      * @param namespace The namespace GUID (e.g., Guid.Namespaces.DNS)
-     * @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', Guid.Namespaces.DNS);
      */
@@ -338,9 +353,9 @@ class Guid {
         try {
             const namespaceStr = typeof namespace === 'string'
                 ? namespace
-                : Guid.toFullHexGuid(namespace);
+                : GuidUint8Array.toFullHexGuid(namespace);
             const v3Guid = uuid.v3(name, namespaceStr);
-            return new Guid(v3Guid);
+            return GuidUint8Array.withVersion(new GuidUint8Array(v3Guid));
         }
         catch (error) {
             if (error instanceof guid_1.GuidError) {
@@ -355,7 +370,7 @@ class Guid {
      * Preferred over v3 as SHA-1 is stronger than MD5.
      * @param name The name to hash within the namespace
      * @param namespace The namespace GUID (e.g., Guid.Namespaces.DNS)
-     * @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', Guid.Namespaces.DNS);
      */
@@ -363,9 +378,9 @@ class Guid {
         try {
             const namespaceStr = typeof namespace === 'string'
                 ? namespace
-                : Guid.toFullHexGuid(namespace);
+                : GuidUint8Array.toFullHexGuid(namespace);
             const v5Guid = uuid.v5(name, namespaceStr);
-            return new Guid(v5Guid);
+            return GuidUint8Array.withVersion(new GuidUint8Array(v5Guid));
         }
         catch (error) {
             if (error instanceof guid_1.GuidError) {
@@ -394,7 +409,7 @@ class Guid {
             const hexString = Array.from(this._value)
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join('');
-            this._cachedFullHex = Guid.toFullHexGuid(hexString);
+            this._cachedFullHex = GuidUint8Array.toFullHexGuid(hexString);
         }
         return this._cachedFullHex;
     }
@@ -410,7 +425,7 @@ class Guid {
      */
     get asShortHexGuid() {
         if (!this._cachedShortHex) {
-            this._cachedShortHex = Guid.toShortHexGuid(this.asFullHexGuid);
+            this._cachedShortHex = GuidUint8Array.toShortHexGuid(this.asFullHexGuid);
         }
         return this._cachedShortHex;
     }
@@ -452,10 +467,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 === GuidUint8Array.BOUNDARY_VALUES.ALL_ZEROS_FULL ||
+            value === GuidUint8Array.BOUNDARY_VALUES.ALL_ZEROS_SHORT ||
+            value === GuidUint8Array.BOUNDARY_VALUES.ALL_FS_FULL ||
+            value === GuidUint8Array.BOUNDARY_VALUES.ALL_FS_SHORT);
     }
     /**
      * Verifies if a given GUID is valid for the given brand.
@@ -468,7 +483,7 @@ class Guid {
             return false;
         }
         try {
-            const verifyFunc = Guid.VerifyFunctions[guidBrand];
+            const verifyFunc = GuidUint8Array.VerifyFunctions[guidBrand];
             return verifyFunc(guid);
         }
         catch {
@@ -481,7 +496,7 @@ class Guid {
      * @returns The length of the GUID for the given brand.
      */
     static guidBrandToLength(guidBrand) {
-        const length = Guid.LengthMap[guidBrand];
+        const length = GuidUint8Array.LengthMap[guidBrand];
         if (length <= 0) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownBrand, guidBrand);
         }
@@ -497,7 +512,7 @@ class Guid {
         if (length <= 0) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
         }
-        const brand = Guid.ReverseLengthMap[length];
+        const brand = GuidUint8Array.ReverseLengthMap[length];
         if (!brand || brand === guid_brand_type_1.GuidBrandType.Unknown) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
         }
@@ -518,16 +533,16 @@ class Guid {
             if (fullHexGuidValue === null || fullHexGuidValue === undefined) {
                 return false;
             }
-            const expectedLength = Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid);
+            const expectedLength = GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid);
             const strValue = String(fullHexGuidValue);
             if (strValue.length !== expectedLength) {
                 return false;
             }
             // Boundary values are always valid
-            if (Guid.isBoundaryValue(strValue)) {
+            if (GuidUint8Array.isBoundaryValue(strValue)) {
                 return true;
             }
-            return Guid.validateUuid(strValue);
+            return GuidUint8Array.validateUuid(strValue);
         }
         catch {
             return false;
@@ -543,15 +558,15 @@ class Guid {
             if (shortHexGuidValue === null || shortHexGuidValue === undefined) {
                 return false;
             }
-            const expectedLength = Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid);
+            const expectedLength = GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid);
             const strValue = String(shortHexGuidValue);
             if (strValue.length !== expectedLength) {
                 return false;
             }
             try {
-                const fullHexGuid = Guid.toFullHexGuid(strValue);
+                const fullHexGuid = GuidUint8Array.toFullHexGuid(strValue);
                 // Boundary values are always valid
-                if (Guid.isBoundaryValue(fullHexGuid)) {
+                if (GuidUint8Array.isBoundaryValue(fullHexGuid)) {
                     return true;
                 }
                 return uuid.validate(fullHexGuid);
@@ -578,22 +593,23 @@ class Guid {
             if (typeof value === 'bigint') {
                 valueLength = value.toString(16).length;
             }
-            else if (Guid.isUint8Array(value)) {
+            else if (GuidUint8Array.isUint8Array(value)) {
                 valueLength = value.length;
             }
             else {
                 valueLength = String(value).length;
             }
-            const result = valueLength === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid);
+            const result = valueLength ===
+                GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid);
             if (result) {
                 try {
-                    const fromBase64 = Guid.toRawGuidPlatformBuffer(value);
+                    const fromBase64 = GuidUint8Array.toRawGuidPlatformBuffer(value);
                     const hexString = Array.from(fromBase64)
                         .map((b) => b.toString(16).padStart(2, '0'))
                         .join('');
-                    const fullHexGuid = Guid.toFullHexGuid(hexString);
+                    const fullHexGuid = GuidUint8Array.toFullHexGuid(hexString);
                     // Boundary values are always valid
-                    if (Guid.isBoundaryValue(fullHexGuid)) {
+                    if (GuidUint8Array.isBoundaryValue(fullHexGuid)) {
                         return true;
                     }
                     return uuid.validate(fullHexGuid);
@@ -618,12 +634,12 @@ class Guid {
             if (value === null || value === undefined) {
                 return false;
             }
-            const expectedLength = Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer);
+            const expectedLength = GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer);
             let valueLength;
             if (typeof value === 'bigint') {
                 valueLength = value.toString(16).length;
             }
-            else if (Guid.isUint8Array(value)) {
+            else if (GuidUint8Array.isUint8Array(value)) {
                 valueLength = value.length;
             }
             else {
@@ -633,18 +649,18 @@ class Guid {
                 return false;
             }
             try {
-                if (!Guid.isUint8Array(value)) {
+                if (!GuidUint8Array.isUint8Array(value)) {
                     return false;
                 }
                 const hexString = Array.from(value)
                     .map((b) => b.toString(16).padStart(2, '0'))
                     .join('');
-                const fullHexGuid = Guid.toFullHexGuid(hexString);
+                const fullHexGuid = GuidUint8Array.toFullHexGuid(hexString);
                 // Boundary values are always valid
-                if (Guid.isBoundaryValue(fullHexGuid)) {
+                if (GuidUint8Array.isBoundaryValue(fullHexGuid)) {
                     return true;
                 }
-                return Guid.validateUuid(fullHexGuid);
+                return GuidUint8Array.validateUuid(fullHexGuid);
             }
             catch {
                 return false;
@@ -667,13 +683,13 @@ class Guid {
             if (typeof value !== 'bigint') {
                 return false;
             }
-            if (value < 0n || value > Guid.MAX_BIGINT_VALUE) {
+            if (value < 0n || value > GuidUint8Array.MAX_BIGINT_VALUE) {
                 return false;
             }
             try {
-                const fromBigInt = Guid.toFullHexFromBigInt(value);
+                const fromBigInt = GuidUint8Array.toFullHexFromBigInt(value);
                 // Boundary values are always valid
-                if (Guid.isBoundaryValue(fromBigInt)) {
+                if (GuidUint8Array.isBoundaryValue(fromBigInt)) {
                     return true;
                 }
                 return uuid.validate(fromBigInt);
@@ -698,11 +714,11 @@ class Guid {
         if (typeof value === 'bigint') {
             return guid_brand_type_1.GuidBrandType.BigIntGuid;
         }
-        const isBuffer = Guid.isUint8Array(value);
+        const isBuffer = GuidUint8Array.isUint8Array(value);
         const expectedLength = isBuffer
             ? value.length
             : String(value).length;
-        return Guid.lengthToGuidBrand(expectedLength, isBuffer);
+        return GuidUint8Array.lengthToGuidBrand(expectedLength, isBuffer);
     }
     /**
      * Converts a given short hex GUID to a full hex GUID.
@@ -724,31 +740,34 @@ class Guid {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         if (typeof guid === 'bigint') {
-            return Guid.toFullHexFromBigInt(guid);
+            return GuidUint8Array.toFullHexFromBigInt(guid);
         }
-        else if (Guid.isUint8Array(guid) &&
+        else if (GuidUint8Array.isUint8Array(guid) &&
             guid.length ===
-                Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
+                GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
             const hexString = Array.from(guid)
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join('');
             const shortHex = hexString;
-            return Guid.shortGuidToFullGuid(shortHex);
+            return GuidUint8Array.shortGuidToFullGuid(shortHex);
         }
-        else if (Guid.isUint8Array(guid)) {
+        else if (GuidUint8Array.isUint8Array(guid)) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         // all remaining cases are string types
         const strValue = String(guid);
-        if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
+        if (strValue.length ===
+            GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
             // short hex guid
-            return Guid.shortGuidToFullGuid(strValue);
+            return GuidUint8Array.shortGuidToFullGuid(strValue);
         }
-        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
+        else if (strValue.length ===
+            GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
             // already a full hex guid
             return strValue;
         }
-        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
+        else if (strValue.length ===
+            GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
             // base64 guid
             // base64 guid
             const binary = atob(strValue);
@@ -759,7 +778,7 @@ class Guid {
             const shortGuid = Array.from(bytes)
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join('');
-            return Guid.shortGuidToFullGuid(shortGuid);
+            return GuidUint8Array.shortGuidToFullGuid(shortGuid);
         }
         else {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
@@ -770,30 +789,33 @@ class Guid {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         if (typeof guid === 'bigint') {
-            const fullHex = Guid.toFullHexFromBigInt(guid);
+            const fullHex = GuidUint8Array.toFullHexFromBigInt(guid);
             return fullHex.replace(/-/g, '');
         }
-        else if (Guid.isUint8Array(guid) &&
+        else if (GuidUint8Array.isUint8Array(guid) &&
             guid.length ===
-                Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
+                GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
             return Array.from(guid)
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join('');
         }
-        else if (Guid.isUint8Array(guid)) {
+        else if (GuidUint8Array.isUint8Array(guid)) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         // all remaining cases are string types
         const strValue = String(guid);
-        if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
+        if (strValue.length ===
+            GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
             // already a short hex guid
             return strValue;
         }
-        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
+        else if (strValue.length ===
+            GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
             // full hex guid
             return strValue.replace(/-/g, '');
         }
-        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
+        else if (strValue.length ===
+            GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
             // base64 guid
             const binary = atob(strValue);
             const bytes = new Uint8Array(binary.length);
@@ -814,7 +836,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 > GuidUint8Array.MAX_BIGINT_VALUE) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         const uuidBigInt = bigInt.toString(16).padStart(32, '0');
@@ -839,11 +861,11 @@ class Guid {
      * @returns The GUID value as a raw GUID array.
      */
     static toRawGuidPlatformBuffer(value) {
-        const expectedBrand = Guid.whichBrand(value);
+        const expectedBrand = GuidUint8Array.whichBrand(value);
         let rawGuidBufferResult = new Uint8Array(0);
         switch (expectedBrand) {
             case guid_brand_type_1.GuidBrandType.FullHexGuid: {
-                const hex1 = Guid.toShortHexGuid(value);
+                const hex1 = GuidUint8Array.toShortHexGuid(value);
                 rawGuidBufferResult = new Uint8Array(hex1.length / 2);
                 for (let i = 0; i < hex1.length; i += 2) {
                     rawGuidBufferResult[i / 2] = parseInt(hex1.slice(i, i + 2), 16);
@@ -851,7 +873,7 @@ class Guid {
                 break;
             }
             case guid_brand_type_1.GuidBrandType.ShortHexGuid: {
-                const hex2 = Guid.toShortHexGuid(value);
+                const hex2 = GuidUint8Array.toShortHexGuid(value);
                 rawGuidBufferResult = new Uint8Array(hex2.length / 2);
                 for (let i = 0; i < hex2.length; i += 2) {
                     rawGuidBufferResult[i / 2] = parseInt(hex2.slice(i, i + 2), 16);
@@ -859,7 +881,7 @@ class Guid {
                 break;
             }
             case guid_brand_type_1.GuidBrandType.Base64Guid:
-                if (typeof value === 'string' || Guid.isUint8Array(value)) {
+                if (typeof value === 'string' || GuidUint8Array.isUint8Array(value)) {
                     const b64 = value.toString();
                     const binary = atob(b64);
                     rawGuidBufferResult = new Uint8Array(binary.length);
@@ -875,7 +897,7 @@ class Guid {
                 rawGuidBufferResult = value;
                 break;
             case guid_brand_type_1.GuidBrandType.BigIntGuid: {
-                const hex3 = Guid.toShortHexGuid(Guid.toFullHexFromBigInt(value));
+                const hex3 = GuidUint8Array.toShortHexGuid(GuidUint8Array.toFullHexFromBigInt(value));
                 rawGuidBufferResult = new Uint8Array(hex3.length / 2);
                 for (let i = 0; i < hex3.length; i += 2) {
                     rawGuidBufferResult[i / 2] = parseInt(hex3.slice(i, i + 2), 16);
@@ -886,7 +908,7 @@ class Guid {
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownBrand);
         }
         if (rawGuidBufferResult.length !==
-            Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
+            GuidUint8Array.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, rawGuidBufferResult.length);
         }
         return rawGuidBufferResult;
@@ -937,14 +959,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 GuidUint8Array && 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(Uint8Array.from(this._value));
+        return GuidUint8Array.withVersion(new GuidUint8Array(Uint8Array.from(this._value)));
     }
     /**
      * Returns the hash code for this GUID based on its array content.
@@ -966,7 +988,7 @@ class Guid {
      */
     getVersion() {
         // Skip boundary values
-        if (Guid.isBoundaryValue(this.asFullHexGuid)) {
+        if (GuidUint8Array.isBoundaryValue(this.asFullHexGuid)) {
             return undefined;
         }
         // Version is in bits 48-51 (byte 6, high nibble)
@@ -989,7 +1011,7 @@ class Guid {
      */
     isValidV4() {
         // Boundary values are considered valid
-        if (Guid.isBoundaryValue(this.asFullHexGuid)) {
+        if (GuidUint8Array.isBoundaryValue(this.asFullHexGuid)) {
             return true;
         }
         const version = this.getVersion();
@@ -1060,12 +1082,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 GuidUint8Array.withVersion(new GuidUint8Array(v1Guid));
         }
         catch (error) {
             if (error instanceof guid_1.GuidError)
@@ -1089,14 +1111,15 @@ 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 GuidUint8Array.withVersion(new GuidUint8Array(base64));
     }
 }
-exports.Guid = Guid;
+exports.GuidUint8Array = GuidUint8Array;
 //# sourceMappingURL=guid.js.map