@digitaldefiance/ecies-lib 4.10.7 → 4.11.0

package/src/lib/guid.js

@@ -1,25 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GuidV4 = void 0;
+exports.Guid = void 0;
 const tslib_1 = require("tslib");
 const uuid = tslib_1.__importStar(require("uuid"));
 const guid_brand_type_1 = require("../enumerations/guid-brand-type");
 const guid_error_type_1 = require("../enumerations/guid-error-type");
 const guid_1 = require("../errors/guid");
-const buffer_compat_1 = require("./buffer-compat");
 /**
- * GuidV4 represents a GUID (Globally Unique Identifier) that is compliant with the RFC 4122 standard.
- * GuidV4 instances can be created from a variety of input types, including:
+ * Guid represents a GUID/UUID (Globally Unique Identifier) that is compliant with the RFC 4122 standard.
+ * Supports all UUID versions (v1-v5), with factory methods for v3, v4, and v5.
+ * Guid instances can be created from a variety of input types, including:
  * - FullHexGuid: A 36-character string representation of the GUID, including dashes
  * - ShortHexGuid: A 32-character string representation of the GUID, excluding dashes
  * - Base64Guid: A 24-character base64-encoded string representation of the GUID
  * - BigIntGuid: A bigint representation of the GUID
- * - RawGuidBuffer: A 16-byte Buffer representation of the GUID
- * GuidV4 instances can be converted to any of these representations using the appropriate method.
+ * - RawGuidUint8Array: A 16-byte Uint8Array representation of the GUID
+ * Guid instances can be converted to any of these representations using the appropriate method.
  */
-class GuidV4 {
+class Guid {
+    /** @deprecated Use Guid instead */
+    static Guid = Guid;
     /**
-     * GUID is stored internally as a raw 16-byte Buffer.
+     * GUID is stored internally as a raw 16-byte Uint8Array.
      */
     _value;
     /**
@@ -61,12 +63,6 @@ class GuidV4 {
     static isUint8Array(value) {
         return value instanceof Uint8Array;
     }
-    /**
-     * Type guard to check if a value is a Buffer or Uint8Array
-     */
-    static isBufferLike(value) {
-        return buffer_compat_1.Buffer.isBuffer(value) || GuidV4.isUint8Array(value);
-    }
     /**
      * Cached empty/nil GUID constant (all zeros)
      */
@@ -75,16 +71,16 @@ class GuidV4 {
      * Empty/nil GUID constant (all zeros)
      */
     static get Empty() {
-        if (!GuidV4._empty) {
-            GuidV4._empty = Object.freeze(new GuidV4('00000000-0000-0000-0000-000000000000'));
+        if (!Guid._empty) {
+            Guid._empty = Object.freeze(new Guid('00000000-0000-0000-0000-000000000000'));
         }
-        return GuidV4._empty;
+        return Guid._empty;
     }
     constructor(value) {
-        const buffer = GuidV4.validateAndConvert(value);
+        const array = Guid.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;
+        // Instead, we ensure the array is never directly modified after construction
+        this._value = array;
         // Initialize cache properties so they exist before sealing
         this._cachedFullHex = undefined;
         this._cachedShortHex = undefined;
@@ -94,10 +90,10 @@ class GuidV4 {
         Object.seal(this);
     }
     /**
-     * Validates input and converts to raw buffer with comprehensive error handling.
+     * Validates input and converts to raw array with comprehensive error handling.
      * This centralizes all validation logic for better maintainability.
      * @param value The input value to validate and convert
-     * @returns The validated raw GUID buffer
+     * @returns The validated raw GUID array
      * @throws {GuidError} If validation fails
      */
     static validateAndConvert(value) {
@@ -119,42 +115,36 @@ class GuidV4 {
             if (typeof value === 'string') {
                 const isFullHex = value.length === 36 && value.includes('-');
                 const isShortHex = value.length === 32 && !value.includes('-');
-                if (isFullHex && !GuidV4.FULL_HEX_PATTERN.test(value)) {
-                    const buffer = buffer_compat_1.Buffer.from(value);
-                    throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidWithDetails, guid_brand_type_1.GuidBrandType.FullHexGuid, value.length, buffer);
+                if (isFullHex && !Guid.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 && !GuidV4.HEX_PATTERN.test(value)) {
-                    const buffer = buffer_compat_1.Buffer.from(value);
-                    throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidWithDetails, guid_brand_type_1.GuidBrandType.ShortHexGuid, value.length, buffer);
+                else if (isShortHex && !Guid.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 = GuidV4.whichBrand(value);
-            const verifiedBrand = GuidV4.verifyGuid(expectedBrand, value);
+            const expectedBrand = Guid.whichBrand(value);
+            const verifiedBrand = Guid.verifyGuid(expectedBrand, value);
             if (!verifiedBrand) {
-                const valueBuffer = buffer_compat_1.Buffer.isBuffer(value)
+                const valueBuffer = Guid.isUint8Array(value)
                     ? value
-                    : buffer_compat_1.Buffer.from(strValue);
+                    : new TextEncoder().encode(strValue);
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidWithDetails, expectedBrand, undefined, valueBuffer);
             }
-            // Convert to raw buffer
-            const buffer = GuidV4.toRawGuidBuffer(value);
+            // Convert to raw array
+            const array = Guid.toRawGuidPlatformBuffer(value);
             // Validate against UUID standard (skip for boundary values)
-            let hexString;
-            if (GuidV4.isUint8Array(buffer) && !buffer_compat_1.Buffer.isBuffer(buffer)) {
-                hexString = Array.from(buffer)
-                    .map((b) => b.toString(16).padStart(2, '0'))
-                    .join('');
-            }
-            else {
-                hexString = buffer.toString('hex');
-            }
-            const fullHex = GuidV4.toFullHexGuid(hexString);
-            const isBoundary = GuidV4.isBoundaryValue(fullHex);
+            const hexString = Array.from(array)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+            const fullHex = Guid.toFullHexGuid(hexString);
+            const isBoundary = Guid.isBoundaryValue(fullHex);
             if (!isBoundary && !uuid.validate(fullHex)) {
-                throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid, expectedBrand, undefined, buffer);
+                throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid, expectedBrand, undefined, array);
             }
-            return buffer;
+            return array;
         }
         catch (error) {
             // Re-throw GuidError as-is
@@ -165,7 +155,7 @@ class GuidV4 {
             if (typeof value === 'bigint') {
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
             }
-            const length = buffer_compat_1.Buffer.isBuffer(value)
+            const length = Guid.isUint8Array(value)
                 ? value.length
                 : String(value).length;
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
@@ -178,14 +168,14 @@ class GuidV4 {
         return this.asBase64Guid;
     }
     static hydrate(value) {
-        return new GuidV4(value);
+        return new Guid(value);
     }
     static LengthMap = {
         [guid_brand_type_1.GuidBrandType.Unknown]: -1,
         [guid_brand_type_1.GuidBrandType.FullHexGuid]: 36,
         [guid_brand_type_1.GuidBrandType.ShortHexGuid]: 32,
         [guid_brand_type_1.GuidBrandType.Base64Guid]: 24,
-        [guid_brand_type_1.GuidBrandType.RawGuidBuffer]: 16,
+        [guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer]: 16,
         [guid_brand_type_1.GuidBrandType.BigIntGuid]: -1, // Variable length
     };
     static ReverseLengthMap = {
@@ -193,7 +183,7 @@ class GuidV4 {
         36: guid_brand_type_1.GuidBrandType.FullHexGuid,
         32: guid_brand_type_1.GuidBrandType.ShortHexGuid,
         24: guid_brand_type_1.GuidBrandType.Base64Guid,
-        16: guid_brand_type_1.GuidBrandType.RawGuidBuffer,
+        16: guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer,
         // BigIntGuid is variable length, so it is not included in the reverse map
     };
     static VerifyFunctions = {
@@ -202,28 +192,28 @@ class GuidV4 {
         [guid_brand_type_1.GuidBrandType.ShortHexGuid]: (guid) => this.isShortHexGuid(guid),
         [guid_brand_type_1.GuidBrandType.Base64Guid]: (guid) => this.isBase64Guid(guid),
         [guid_brand_type_1.GuidBrandType.BigIntGuid]: (guid) => this.isBigIntGuid(guid),
-        [guid_brand_type_1.GuidBrandType.RawGuidBuffer]: (guid) => this.isRawGuidBuffer(guid),
+        [guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer]: (guid) => this.isRawGuidUint8Array(guid),
     };
     /**
-     * Returns the GUID as a raw Buffer.
+     * Returns the GUID as a raw Uint8Array.
      * NOTE: Returns a defensive copy to prevent external mutation.
-     * Use asRawGuidBufferUnsafe() if you need the internal buffer and guarantee no mutation.
+     * Use asRawGuidUint8ArrayUnsafe() if you need the internal array and guarantee no mutation.
      */
-    get asRawGuidBuffer() {
-        return buffer_compat_1.Buffer.from(this._value);
+    get asRawGuidPlatformBuffer() {
+        return new Uint8Array(this._value);
     }
     /**
-     * Returns the internal raw Buffer without copying.
-     * ⚠️ WARNING: Do NOT mutate the returned buffer! This is for performance-critical paths only.
-     * Mutating this buffer will corrupt the GUID instance.
+     * Returns the internal raw Uint8Array without copying.
+     * ⚠️ WARNING: Do NOT mutate the returned array! This is for performance-critical paths only.
+     * Mutating this array will corrupt the GUID instance.
      * @internal
      */
-    get asRawGuidBufferUnsafe() {
+    get asRawGuidPlatformBufferUnsafe() {
         return this._value;
     }
     /**
      * Generates a new random v4 GUID.
-     * @returns A new GuidV4 instance with a randomly generated value
+     * @returns A new Guid instance with a randomly generated value
      */
     static generate() {
         try {
@@ -231,7 +221,7 @@ class GuidV4 {
             if (!uuidStr) {
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
             }
-            return new GuidV4(uuidStr);
+            return new Guid(uuidStr);
         }
         catch (error) {
             if (error instanceof guid_1.GuidError) {
@@ -240,32 +230,39 @@ class GuidV4 {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
     }
+    /**
+     * Alias for generate() to create a v4 GUID.
+     * @returns A new Guid instance with a randomly generated v4 value
+     */
+    static v4() {
+        return Guid.generate();
+    }
     /**
      * Alias for generate() for backward compatibility.
      * @deprecated Use generate() instead for clearer intent
      */
     static new() {
-        return GuidV4.generate();
+        return Guid.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 GuidV4 instance
+     * @returns A new Guid instance
      * @throws {GuidError} If the value is not a valid GUID
      */
     static parse(value) {
-        return new GuidV4(value);
+        return new Guid(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 GuidV4 instance or null if parsing fails
+     * @returns A new Guid instance or null if parsing fails
      */
     static tryParse(value) {
         try {
-            return new GuidV4(value);
+            return new Guid(value);
         }
         catch {
             return null;
@@ -281,7 +278,7 @@ class GuidV4 {
         if (!value)
             return false;
         try {
-            const guid = new GuidV4(value);
+            const guid = new Guid(value);
             return guid.isValidV4();
         }
         catch {
@@ -291,69 +288,61 @@ class GuidV4 {
     /**
      * Factory method to create a GUID from a full hex string.
      * @param fullHex The full hex string (with dashes)
-     * @returns A new GuidV4 instance
+     * @returns A new Guid instance
      */
     static fromFullHex(fullHex) {
-        return new GuidV4(fullHex);
+        return new Guid(fullHex);
     }
     /**
      * Factory method to create a GUID from a short hex string.
      * @param shortHex The short hex string (without dashes)
-     * @returns A new GuidV4 instance
+     * @returns A new Guid instance
      */
     static fromShortHex(shortHex) {
-        return new GuidV4(shortHex);
+        return new Guid(shortHex);
     }
     /**
      * Factory method to create a GUID from a base64 string.
      * @param base64 The base64 encoded string
-     * @returns A new GuidV4 instance
+     * @returns A new Guid instance
      */
     static fromBase64(base64) {
-        return new GuidV4(base64);
+        return new Guid(base64);
     }
     /**
      * Factory method to create a GUID from a bigint.
      * @param bigint The bigint value
-     * @returns A new GuidV4 instance
+     * @returns A new Guid instance
      */
     static fromBigInt(bigint) {
-        return new GuidV4(bigint);
-    }
-    /**
-     * Factory method to create a GUID from a raw buffer.
-     * @param buffer The raw 16-byte buffer
-     * @returns A new GuidV4 instance
-     */
-    static fromBuffer(buffer) {
-        return new GuidV4(buffer);
+        return new Guid(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 GuidV4 instance
+     * @returns A new Guid instance
      */
-    static fromUint8Array(bytes) {
-        return new GuidV4(bytes);
+    static fromPlatformBuffer(bytes) {
+        return new Guid(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 GuidV4 instance containing the v3 GUID
+     * @param namespace The namespace GUID (e.g., Guid.Namespaces.DNS)
+     * @returns A new Guid instance containing the v3 GUID
      * @example
-     * const guid = GuidV4.v3('example.com', uuid.v3.DNS);
+     * const guid = Guid.v3('example.com', Guid.Namespaces.DNS);
      */
     static v3(name, namespace) {
         try {
-            const namespaceStr = buffer_compat_1.Buffer.isBuffer(namespace)
-                ? GuidV4.toFullHexGuid(namespace.toString('hex'))
-                : namespace;
+            const namespaceStr = typeof namespace === 'string'
+                ? namespace
+                : Guid.toFullHexGuid(namespace);
             const v3Guid = uuid.v3(name, namespaceStr);
-            return new GuidV4(v3Guid);
+            return new Guid(v3Guid);
         }
         catch (error) {
             if (error instanceof guid_1.GuidError) {
@@ -366,19 +355,19 @@ class GuidV4 {
      * Creates a namespace-based v5 GUID (SHA-1 hash).
      * Use this for deterministic GUIDs based on a namespace and name.
      * 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 GuidV4 instance containing the v5 GUID
+     * @param namespace The namespace GUID (e.g., Guid.Namespaces.DNS)
+     * @returns A new Guid instance containing the v5 GUID
      * @example
-     * const guid = GuidV4.v5('example.com', uuid.v5.DNS);
+     * const guid = Guid.v5('example.com', Guid.Namespaces.DNS);
      */
     static v5(name, namespace) {
         try {
-            const namespaceStr = buffer_compat_1.Buffer.isBuffer(namespace)
-                ? GuidV4.toFullHexGuid(namespace.toString('hex'))
-                : namespace;
+            const namespaceStr = typeof namespace === 'string'
+                ? namespace
+                : Guid.toFullHexGuid(namespace);
             const v5Guid = uuid.v5(name, namespaceStr);
-            return new GuidV4(v5Guid);
+            return new Guid(v5Guid);
         }
         catch (error) {
             if (error instanceof guid_1.GuidError) {
@@ -404,23 +393,17 @@ class GuidV4 {
      */
     get asFullHexGuid() {
         if (!this._cachedFullHex) {
-            let hexString;
-            if (GuidV4.isUint8Array(this._value) && !buffer_compat_1.Buffer.isBuffer(this._value)) {
-                hexString = Array.from(this._value)
-                    .map((b) => b.toString(16).padStart(2, '0'))
-                    .join('');
-            }
-            else {
-                hexString = this._value.toString('hex');
-            }
-            this._cachedFullHex = GuidV4.toFullHexGuid(hexString);
+            const hexString = Array.from(this._value)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+            this._cachedFullHex = Guid.toFullHexGuid(hexString);
         }
         return this._cachedFullHex;
     }
     /**
      * Returns the GUID as a raw Uint8Array.
      */
-    get asUint8Array() {
+    get asPlatformBuffer() {
         return this._value;
     }
     /**
@@ -429,7 +412,7 @@ class GuidV4 {
      */
     get asShortHexGuid() {
         if (!this._cachedShortHex) {
-            this._cachedShortHex = GuidV4.toShortHexGuid(this.asFullHexGuid);
+            this._cachedShortHex = Guid.toShortHexGuid(this.asFullHexGuid);
         }
         return this._cachedShortHex;
     }
@@ -450,7 +433,10 @@ class GuidV4 {
      * Returns the GUID as a bigint.
      */
     get asBigIntGuid() {
-        return BigInt('0x' + this._value.toString('hex'));
+        const hexString = Array.from(this._value)
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+        return BigInt('0x' + hexString);
     }
     /**
      * Returns the GUID as a base64 string.
@@ -458,7 +444,7 @@ class GuidV4 {
      */
     get asBase64Guid() {
         if (!this._cachedBase64) {
-            this._cachedBase64 = this._value.toString('base64');
+            this._cachedBase64 = btoa(String.fromCharCode(...this._value));
         }
         return this._cachedBase64;
     }
@@ -468,10 +454,10 @@ class GuidV4 {
      * @returns True if the value is a boundary value.
      */
     static isBoundaryValue(value) {
-        return (value === GuidV4.BOUNDARY_VALUES.ALL_ZEROS_FULL ||
-            value === GuidV4.BOUNDARY_VALUES.ALL_ZEROS_SHORT ||
-            value === GuidV4.BOUNDARY_VALUES.ALL_FS_FULL ||
-            value === GuidV4.BOUNDARY_VALUES.ALL_FS_SHORT);
+        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);
     }
     /**
      * Verifies if a given GUID is valid for the given brand.
@@ -484,7 +470,7 @@ class GuidV4 {
             return false;
         }
         try {
-            const verifyFunc = GuidV4.VerifyFunctions[guidBrand];
+            const verifyFunc = Guid.VerifyFunctions[guidBrand];
             return verifyFunc(guid);
         }
         catch {
@@ -497,7 +483,7 @@ class GuidV4 {
      * @returns The length of the GUID for the given brand.
      */
     static guidBrandToLength(guidBrand) {
-        const length = GuidV4.LengthMap[guidBrand];
+        const length = Guid.LengthMap[guidBrand];
         if (length <= 0) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownBrand, guidBrand);
         }
@@ -506,20 +492,20 @@ class GuidV4 {
     /**
      * Returns the brand of the GUID for the given length.
      * @param length The length of the GUID to get the brand for.
-     * @param isBuffer Whether the GUID is a Buffer.
+     * @param isUint8Array Whether the GUID is a Uint8Array.
      * @returns The brand of the GUID for the given length.
      */
-    static lengthToGuidBrand(length, isBuffer) {
+    static lengthToGuidBrand(length, isUint8Array) {
         if (length <= 0) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
         }
-        const brand = GuidV4.ReverseLengthMap[length];
+        const brand = Guid.ReverseLengthMap[length];
         if (!brand || brand === guid_brand_type_1.GuidBrandType.Unknown) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
         }
-        // Validate buffer vs string type consistency
-        const isBrandBuffer = brand === guid_brand_type_1.GuidBrandType.RawGuidBuffer;
-        if (isBuffer !== isBrandBuffer) {
+        // Validate array vs string type consistency
+        const isBrandUint8Array = brand === guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer;
+        if (isUint8Array !== isBrandUint8Array) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, brand, length);
         }
         return brand;
@@ -534,16 +520,16 @@ class GuidV4 {
             if (fullHexGuidValue === null || fullHexGuidValue === undefined) {
                 return false;
             }
-            const expectedLength = GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid);
+            const expectedLength = Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid);
             const strValue = String(fullHexGuidValue);
             if (strValue.length !== expectedLength) {
                 return false;
             }
             // Boundary values are always valid
-            if (GuidV4.isBoundaryValue(strValue)) {
+            if (Guid.isBoundaryValue(strValue)) {
                 return true;
             }
-            return GuidV4.validateUuid(strValue);
+            return Guid.validateUuid(strValue);
         }
         catch {
             return false;
@@ -559,15 +545,15 @@ class GuidV4 {
             if (shortHexGuidValue === null || shortHexGuidValue === undefined) {
                 return false;
             }
-            const expectedLength = GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid);
+            const expectedLength = Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid);
             const strValue = String(shortHexGuidValue);
             if (strValue.length !== expectedLength) {
                 return false;
             }
             try {
-                const fullHexGuid = GuidV4.toFullHexGuid(strValue);
+                const fullHexGuid = Guid.toFullHexGuid(strValue);
                 // Boundary values are always valid
-                if (GuidV4.isBoundaryValue(fullHexGuid)) {
+                if (Guid.isBoundaryValue(fullHexGuid)) {
                     return true;
                 }
                 return uuid.validate(fullHexGuid);
@@ -594,28 +580,22 @@ class GuidV4 {
             if (typeof value === 'bigint') {
                 valueLength = value.toString(16).length;
             }
-            else if (GuidV4.isBufferLike(value)) {
+            else if (Guid.isUint8Array(value)) {
                 valueLength = value.length;
             }
             else {
                 valueLength = String(value).length;
             }
-            const result = valueLength === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid);
+            const result = valueLength === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid);
             if (result) {
                 try {
-                    const fromBase64 = GuidV4.toRawGuidBuffer(value);
-                    let hexString;
-                    if (GuidV4.isUint8Array(fromBase64) && !buffer_compat_1.Buffer.isBuffer(fromBase64)) {
-                        hexString = Array.from(fromBase64)
-                            .map((b) => b.toString(16).padStart(2, '0'))
-                            .join('');
-                    }
-                    else {
-                        hexString = fromBase64.toString('hex');
-                    }
-                    const fullHexGuid = GuidV4.toFullHexGuid(hexString);
+                    const fromBase64 = Guid.toRawGuidPlatformBuffer(value);
+                    const hexString = Array.from(fromBase64)
+                        .map((b) => b.toString(16).padStart(2, '0'))
+                        .join('');
+                    const fullHexGuid = Guid.toFullHexGuid(hexString);
                     // Boundary values are always valid
-                    if (GuidV4.isBoundaryValue(fullHexGuid)) {
+                    if (Guid.isBoundaryValue(fullHexGuid)) {
                         return true;
                     }
                     return uuid.validate(fullHexGuid);
@@ -631,21 +611,21 @@ class GuidV4 {
         }
     }
     /**
-     * Verifies if a given GUID is a valid raw GUID buffer.
-     * @param value The raw GUID buffer to verify.
-     * @returns True if the GUID is a valid raw GUID buffer, false otherwise.
+     * Verifies if a given GUID is a valid raw GUID array.
+     * @param value The raw GUID array to verify.
+     * @returns True if the GUID is a valid raw GUID array, false otherwise.
      */
-    static isRawGuidBuffer(value) {
+    static isRawGuidUint8Array(value) {
         try {
             if (value === null || value === undefined) {
                 return false;
             }
-            const expectedLength = GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidBuffer);
+            const expectedLength = Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer);
             let valueLength;
             if (typeof value === 'bigint') {
                 valueLength = value.toString(16).length;
             }
-            else if (GuidV4.isBufferLike(value)) {
+            else if (Guid.isUint8Array(value)) {
                 valueLength = value.length;
             }
             else {
@@ -655,24 +635,18 @@ class GuidV4 {
                 return false;
             }
             try {
-                if (!GuidV4.isBufferLike(value)) {
+                if (!Guid.isUint8Array(value)) {
                     return false;
                 }
-                let hexString;
-                if (GuidV4.isUint8Array(value) && !buffer_compat_1.Buffer.isBuffer(value)) {
-                    hexString = Array.from(value)
-                        .map((b) => b.toString(16).padStart(2, '0'))
-                        .join('');
-                }
-                else {
-                    hexString = value.toString('hex');
-                }
-                const fullHexGuid = GuidV4.toFullHexGuid(hexString);
+                const hexString = Array.from(value)
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join('');
+                const fullHexGuid = Guid.toFullHexGuid(hexString);
                 // Boundary values are always valid
-                if (GuidV4.isBoundaryValue(fullHexGuid)) {
+                if (Guid.isBoundaryValue(fullHexGuid)) {
                     return true;
                 }
-                return GuidV4.validateUuid(fullHexGuid);
+                return Guid.validateUuid(fullHexGuid);
             }
             catch {
                 return false;
@@ -695,13 +669,13 @@ class GuidV4 {
             if (typeof value !== 'bigint') {
                 return false;
             }
-            if (value < 0n || value > GuidV4.MAX_BIGINT_VALUE) {
+            if (value < 0n || value > Guid.MAX_BIGINT_VALUE) {
                 return false;
             }
             try {
-                const fromBigInt = GuidV4.toFullHexFromBigInt(value);
+                const fromBigInt = Guid.toFullHexFromBigInt(value);
                 // Boundary values are always valid
-                if (GuidV4.isBoundaryValue(fromBigInt)) {
+                if (Guid.isBoundaryValue(fromBigInt)) {
                     return true;
                 }
                 return uuid.validate(fromBigInt);
@@ -726,11 +700,11 @@ class GuidV4 {
         if (typeof value === 'bigint') {
             return guid_brand_type_1.GuidBrandType.BigIntGuid;
         }
-        const isBuffer = GuidV4.isBufferLike(value);
+        const isBuffer = Guid.isUint8Array(value);
         const expectedLength = isBuffer
             ? value.length
             : String(value).length;
-        return GuidV4.lengthToGuidBrand(expectedLength, isBuffer);
+        return Guid.lengthToGuidBrand(expectedLength, isBuffer);
     }
     /**
      * Converts a given short hex GUID to a full hex GUID.
@@ -752,39 +726,42 @@ class GuidV4 {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         if (typeof guid === 'bigint') {
-            return GuidV4.toFullHexFromBigInt(guid);
+            return Guid.toFullHexFromBigInt(guid);
         }
-        else if (GuidV4.isBufferLike(guid) &&
-            guid.length === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidBuffer)) {
-            let hexString;
-            if (GuidV4.isUint8Array(guid) && !buffer_compat_1.Buffer.isBuffer(guid)) {
-                hexString = Array.from(guid)
-                    .map((b) => b.toString(16).padStart(2, '0'))
-                    .join('');
-            }
-            else {
-                hexString = guid.toString('hex');
-            }
+        else if (Guid.isUint8Array(guid) &&
+            guid.length ===
+                Guid.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 GuidV4.shortGuidToFullGuid(shortHex);
+            return Guid.shortGuidToFullGuid(shortHex);
         }
-        else if (GuidV4.isBufferLike(guid)) {
+        else if (Guid.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 === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
+        if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
             // short hex guid
-            return GuidV4.shortGuidToFullGuid(strValue);
+            return Guid.shortGuidToFullGuid(strValue);
         }
-        else if (strValue.length === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
+        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
             // already a full hex guid
             return strValue;
         }
-        else if (strValue.length === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
+        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
+            // base64 guid
             // base64 guid
-            const shortGuid = buffer_compat_1.Buffer.from(strValue, 'base64').toString('hex');
-            return GuidV4.shortGuidToFullGuid(shortGuid);
+            const binary = atob(strValue);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
+            }
+            const shortGuid = Array.from(bytes)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+            return Guid.shortGuidToFullGuid(shortGuid);
         }
         else {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
@@ -795,36 +772,39 @@ class GuidV4 {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         if (typeof guid === 'bigint') {
-            const fullHex = GuidV4.toFullHexFromBigInt(guid);
+            const fullHex = Guid.toFullHexFromBigInt(guid);
             return fullHex.replace(/-/g, '');
         }
-        else if (GuidV4.isBufferLike(guid) &&
-            guid.length === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidBuffer)) {
-            if (GuidV4.isUint8Array(guid) && !buffer_compat_1.Buffer.isBuffer(guid)) {
-                return Array.from(guid)
-                    .map((b) => b.toString(16).padStart(2, '0'))
-                    .join('');
-            }
-            else {
-                return guid.toString('hex');
-            }
+        else if (Guid.isUint8Array(guid) &&
+            guid.length ===
+                Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
+            return Array.from(guid)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
         }
-        else if (GuidV4.isBufferLike(guid)) {
+        else if (Guid.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 === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
+        if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.ShortHexGuid)) {
             // already a short hex guid
             return strValue;
         }
-        else if (strValue.length === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
+        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.FullHexGuid)) {
             // full hex guid
             return strValue.replace(/-/g, '');
         }
-        else if (strValue.length === GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
+        else if (strValue.length === Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.Base64Guid)) {
             // base64 guid
-            return buffer_compat_1.Buffer.from(strValue, 'base64').toString('hex');
+            const binary = atob(strValue);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
+            }
+            return Array.from(bytes)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
         }
         else {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
@@ -836,7 +816,7 @@ class GuidV4 {
      * @returns The bigint as a full hex GUID.
      */
     static toFullHexFromBigInt(bigInt) {
-        if (bigInt < 0n || bigInt > GuidV4.MAX_BIGINT_VALUE) {
+        if (bigInt < 0n || bigInt > Guid.MAX_BIGINT_VALUE) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
         }
         const uuidBigInt = bigInt.toString(16).padStart(32, '0');
@@ -856,66 +836,89 @@ class GuidV4 {
         return rebuiltUuid;
     }
     /**
-     * Converts a given GUID value to a raw GUID buffer.
+     * Converts a given GUID value to a raw GUID array.
      * @param value The GUID value to convert.
-     * @returns The GUID value as a raw GUID buffer.
+     * @returns The GUID value as a raw GUID array.
      */
-    static toRawGuidBuffer(value) {
-        const expectedBrand = GuidV4.whichBrand(value);
-        let rawGuidBufferResult = buffer_compat_1.Buffer.alloc(0);
+    static toRawGuidPlatformBuffer(value) {
+        const expectedBrand = Guid.whichBrand(value);
+        let rawGuidBufferResult = new Uint8Array(0);
         switch (expectedBrand) {
-            case guid_brand_type_1.GuidBrandType.FullHexGuid:
-                rawGuidBufferResult = buffer_compat_1.Buffer.from(GuidV4.toShortHexGuid(value), 'hex');
+            case guid_brand_type_1.GuidBrandType.FullHexGuid: {
+                const hex1 = Guid.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);
+                }
                 break;
-            case guid_brand_type_1.GuidBrandType.ShortHexGuid:
-                rawGuidBufferResult = buffer_compat_1.Buffer.from(GuidV4.toShortHexGuid(value), 'hex');
+            }
+            case guid_brand_type_1.GuidBrandType.ShortHexGuid: {
+                const hex2 = Guid.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);
+                }
                 break;
+            }
             case guid_brand_type_1.GuidBrandType.Base64Guid:
-                // Ensure value is a string before using it with Buffer.from
-                if (typeof value === 'string' || buffer_compat_1.Buffer.isBuffer(value)) {
-                    rawGuidBufferResult = buffer_compat_1.Buffer.from(value.toString(), 'base64');
+                if (typeof value === 'string' || Guid.isUint8Array(value)) {
+                    const b64 = value.toString();
+                    const binary = atob(b64);
+                    rawGuidBufferResult = new Uint8Array(binary.length);
+                    for (let i = 0; i < binary.length; i++) {
+                        rawGuidBufferResult[i] = binary.charCodeAt(i);
+                    }
                 }
                 else {
                     throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
                 }
                 break;
-            case guid_brand_type_1.GuidBrandType.RawGuidBuffer:
+            case guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer:
                 rawGuidBufferResult = value;
                 break;
-            case guid_brand_type_1.GuidBrandType.BigIntGuid:
-                rawGuidBufferResult = buffer_compat_1.Buffer.from(GuidV4.toShortHexGuid(GuidV4.toFullHexFromBigInt(value)), 'hex');
+            case guid_brand_type_1.GuidBrandType.BigIntGuid: {
+                const hex3 = Guid.toShortHexGuid(Guid.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);
+                }
                 break;
+            }
             default:
                 throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownBrand);
         }
         if (rawGuidBufferResult.length !==
-            GuidV4.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidBuffer)) {
+            Guid.guidBrandToLength(guid_brand_type_1.GuidBrandType.RawGuidPlatformBuffer)) {
             throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuidUnknownLength, undefined, rawGuidBufferResult.length);
         }
         return rawGuidBufferResult;
     }
     /**
-     * Compare two GuidV4 instances for equality.
-     * @param other - The other GuidV4 instance to compare (can be null/undefined)
+     * Compare two Guid instances for equality.
+     * @param other - The other Guid instance to compare (can be null/undefined)
      * @param constantTime - Use constant-time comparison to prevent timing attacks (default: false)
-     * @returns True if the two GuidV4 instances are equal, false otherwise
+     * @returns True if the two Guid instances are equal, false otherwise
      */
     equals(other, constantTime = false) {
         if (!other) {
             return false;
         }
         if (constantTime) {
-            // Constant-time comparison to prevent timing attacks
-            // Always compare all 16 bytes regardless of early mismatches
-            const a = this.asRawGuidBufferUnsafe;
-            const b = other.asRawGuidBuffer;
+            const a = this.asRawGuidPlatformBufferUnsafe;
+            const b = other.asRawGuidPlatformBuffer;
             let result = 0;
             for (let i = 0; i < 16; i++) {
                 result |= a[i] ^ b[i];
             }
             return result === 0;
         }
-        return (buffer_compat_1.Buffer.compare(this.asRawGuidBufferUnsafe, other.asRawGuidBuffer) === 0);
+        const a = this.asRawGuidPlatformBufferUnsafe;
+        const b = other.asRawGuidPlatformBuffer;
+        for (let i = 0; i < 16; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
     }
     /**
      * Checks if this GUID is empty (all zeros).
@@ -936,17 +939,17 @@ class GuidV4 {
      * @returns True if the GUID is null, undefined, or empty
      */
     static isNilOrEmpty(guid) {
-        return !guid || (guid instanceof GuidV4 && guid.isEmpty());
+        return !guid || (guid instanceof Guid && guid.isEmpty());
     }
     /**
-     * Creates a new GuidV4 instance with the same value as this one.
-     * @returns A new GuidV4 instance with identical value
+     * Creates a new Guid instance with the same value as this one.
+     * @returns A new Guid instance with identical value
      */
     clone() {
-        return new GuidV4(buffer_compat_1.Buffer.from(this._value));
+        return new Guid(Uint8Array.from(this._value));
     }
     /**
-     * Returns the hash code for this GUID based on its buffer content.
+     * Returns the hash code for this GUID based on its array content.
      * Useful for using GUIDs as Map/Set keys.
      * @returns A numeric hash code
      */
@@ -965,7 +968,7 @@ class GuidV4 {
      */
     getVersion() {
         // Skip boundary values
-        if (GuidV4.isBoundaryValue(this.asFullHexGuid)) {
+        if (Guid.isBoundaryValue(this.asFullHexGuid)) {
             return undefined;
         }
         // Version is in bits 48-51 (byte 6, high nibble)
@@ -974,6 +977,13 @@ class GuidV4 {
         // Valid RFC 4122 versions are 1-5
         return version >= 1 && version <= 5 ? version : undefined;
     }
+    /**
+     * Validates that this GUID is a proper v3 GUID according to RFC 4122.
+     * @returns True if valid v3 GUID, false otherwise
+     */
+    isValidV3() {
+        return this.getVersion() === 3;
+    }
     /**
      * Validates that this GUID is a proper v4 GUID according to RFC 4122.
      * Boundary values (all zeros/all Fs) return true as they're mathematically valid.
@@ -981,12 +991,27 @@ class GuidV4 {
      */
     isValidV4() {
         // Boundary values are considered valid
-        if (GuidV4.isBoundaryValue(this.asFullHexGuid)) {
+        if (Guid.isBoundaryValue(this.asFullHexGuid)) {
             return true;
         }
         const version = this.getVersion();
         return version === 4;
     }
+    /**
+     * Validates that this GUID is a proper v5 GUID according to RFC 4122.
+     * @returns True if valid v5 GUID, false otherwise
+     */
+    isValidV5() {
+        return this.getVersion() === 5;
+    }
+    /**
+     * Returns a human-readable string representation.
+     */
+    toDebugString() {
+        const version = this.getVersion();
+        const variant = this.getVariant();
+        return `Guid(${this.asFullHexGuid}, v${version ?? '?'}, variant=${variant ?? '?'})`;
+    }
     /**
      * Compares two GUIDs for ordering.
      * Useful for sorting GUID arrays.
@@ -994,8 +1019,86 @@ class GuidV4 {
      * @returns -1 if this < other, 0 if equal, 1 if this > other
      */
     compareTo(other) {
-        return buffer_compat_1.Buffer.compare(this.asRawGuidBufferUnsafe, other.asRawGuidBuffer);
+        const a = this.asRawGuidPlatformBufferUnsafe;
+        const b = other.asRawGuidPlatformBuffer;
+        for (let i = 0; i < 16; i++) {
+            if (a[i] < b[i])
+                return -1;
+            if (a[i] > b[i])
+                return 1;
+        }
+        return 0;
+    }
+    /**
+     * Returns the timestamp from a v1 GUID.
+     * @returns Date object or undefined if not a v1 GUID
+     */
+    getTimestamp() {
+        if (this.getVersion() !== 1)
+            return undefined;
+        const bytes = this._value;
+        const timeLow = (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
+        const timeMid = (bytes[4] << 8) | bytes[5];
+        const timeHigh = ((bytes[6] & 0x0f) << 8) | bytes[7];
+        const timestamp = (BigInt(timeHigh) << 48n) |
+            (BigInt(timeMid) << 32n) |
+            BigInt(timeLow >>> 0);
+        const unixTimestamp = Number(timestamp - 122192928000000000n) / 10000;
+        return new Date(unixTimestamp);
+    }
+    /**
+     * Extracts the variant from the GUID.
+     * @returns The variant (0-2) or undefined
+     */
+    getVariant() {
+        const variantByte = this._value[8];
+        if ((variantByte & 0x80) === 0)
+            return 0; // NCS
+        if ((variantByte & 0xc0) === 0x80)
+            return 1; // RFC 4122
+        if ((variantByte & 0xe0) === 0xc0)
+            return 2; // Microsoft
+        return undefined;
+    }
+    /**
+     * Creates a v1 GUID (time-based).
+     * @returns A new Guid instance containing a v1 GUID
+     */
+    static v1() {
+        try {
+            const v1Guid = uuid.v1();
+            return new Guid(v1Guid);
+        }
+        catch (error) {
+            if (error instanceof guid_1.GuidError)
+                throw error;
+            throw new guid_1.GuidError(guid_error_type_1.GuidErrorType.InvalidGuid);
+        }
+    }
+    /**
+     * Validates that this GUID is a proper v1 GUID.
+     * @returns True if valid v1 GUID, false otherwise
+     */
+    isValidV1() {
+        return this.getVersion() === 1;
+    }
+    /**
+     * Returns a URL-safe base64 representation (no padding, URL-safe chars).
+     */
+    get asUrlSafeBase64() {
+        const base64 = btoa(String.fromCharCode(...this._value));
+        return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    }
+    /**
+     * Creates a GUID from URL-safe base64.
+     */
+    static fromUrlSafeBase64(urlSafe) {
+        const base64 = urlSafe
+            .replace(/-/g, '+')
+            .replace(/_/g, '/')
+            .padEnd(24, '=');
+        return new Guid(base64);
     }
 }
-exports.GuidV4 = GuidV4;
+exports.Guid = Guid;
 //# sourceMappingURL=guid.js.map