@digitaldefiance/node-ecies-lib 4.13.0 → 4.13.6

package/src/lib/guid.js

@@ -1,435 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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.
+ * Extends GuidUint8Array from ecies-lib to ensure type compatibility while using Buffer internally.
  */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const ecies_lib_1 = require("@digitaldefiance/ecies-lib");
-const uuid = tslib_1.__importStar(require("uuid"));
 /**
- * Guid represents a GUID (Globally Unique Identifier) that is compliant with the RFC 4122 standard.
- * 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
- * - RawGuidPlatformBuffer: A 16-byte Buffer representation of the GUID
- * Guid instances can be converted to any of these representations using the appropriate method.
+ * Node.js GUID implementation that extends GuidUint8Array but uses Buffer internally.
+ * This ensures type compatibility with ecies-lib while leveraging Node.js Buffer capabilities.
  */
-class GuidBuffer {
-    /**
-     * GUID is stored internally as a raw 16-byte Buffer.
-     */
-    _value;
-    /**
-     * Boundary value constants for special GUID validation
-     */
-    static BOUNDARY_VALUES = {
-        ALL_ZEROS_FULL: '00000000-0000-0000-0000-000000000000',
-        ALL_ZEROS_SHORT: '00000000000000000000000000000000',
-        ALL_FS_FULL: 'ffffffff-ffff-ffff-ffff-ffffffffffff',
-        ALL_FS_SHORT: 'ffffffffffffffffffffffffffffffff',
-    };
-    /**
-     * Maximum valid bigint value for a 128-bit GUID
-     */
-    static MAX_BIGINT_VALUE = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');
-    /**
-     * Cached full hex representation for performance
-     */
-    _cachedFullHex;
-    /**
-     * Cached short hex representation for performance
-     */
-    _cachedShortHex;
-    /**
-     * 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)
-     */
-    static HEX_PATTERN = /^[0-9a-f]+$/i;
-    /**
-     * Regex for validating full hex GUID format
-     */
-    static FULL_HEX_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    /**
-     * Type guard to check if a value is a Buffer
-     */
-    static isBuffer(value) {
-        return Buffer.isBuffer(value);
-    }
-    /**
-     * Type guard to check if a value is a Buffer or Uint8Array
-     */
-    static isBufferLike(value) {
-        return Buffer.isBuffer(value) || value instanceof Uint8Array;
-    }
-    /**
-     * Cached empty/nil GUID constant (all zeros)
-     */
-    static _empty;
-    /**
-     * Empty/nil GUID constant (all zeros)
-     */
-    static get Empty() {
-        if (!GuidBuffer._empty) {
-            GuidBuffer._empty = Object.freeze(new GuidBuffer('00000000-0000-0000-0000-000000000000'));
-        }
-        return GuidBuffer._empty;
-    }
+class GuidBuffer extends ecies_lib_1.GuidUint8Array {
     constructor(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;
-        // Initialize cache properties so they exist before sealing
-        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);
-    }
-    /**
-     * Validates input and converts to raw buffer 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
-     * @throws {GuidError} If validation fails
-     */
-    static validateAndConvert(value) {
-        try {
-            // Null/undefined check
-            if (value === null || value === undefined) {
-                throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-            }
-            // Empty string check (but allow 0n bigint)
-            const strValue = String(value);
-            if (!strValue && value !== 0n) {
-                throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-            }
-            // Validate bigint is non-negative
-            if (typeof value === 'bigint' && value < 0n) {
-                throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-            }
-            // Validate hex strings contain only valid hex characters
-            if (typeof value === 'string') {
-                const isFullHex = value.length === 36 && value.includes('-');
-                const isShortHex = value.length === 32 && !value.includes('-');
-                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 && !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 = GuidBuffer.whichBrand(value);
-            const verifiedBrand = GuidBuffer.verifyGuid(expectedBrand, value);
-            if (!verifiedBrand) {
-                const valueBuffer = Buffer.isBuffer(value)
-                    ? value
-                    : Buffer.from(strValue);
-                throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidWithDetails, expectedBrand, undefined, valueBuffer);
-            }
-            // Convert to raw buffer
-            const buffer = GuidBuffer.toRawGuidPlatformBuffer(value);
-            // Validate against UUID standard (skip for boundary values)
-            const hexString = buffer.toString('hex');
-            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);
-            }
-            return buffer;
+        // Convert to Buffer if it's a Uint8Array
+        const bufferValue = value instanceof Uint8Array && !Buffer.isBuffer(value)
+            ? Buffer.from(value)
+            : value;
+        super(bufferValue);
+        // Ensure _value is a Buffer
+        if (!Buffer.isBuffer(this._value)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            this._value = Buffer.from(this._value);
         }
-        catch (error) {
-            // Re-throw GuidError as-is
-            if (error instanceof ecies_lib_1.GuidError) {
-                throw error;
-            }
-            // Wrap other errors with context
-            if (typeof value === 'bigint') {
-                throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-            }
-            const length = Buffer.isBuffer(value)
-                ? value.length
-                : String(value).length;
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownLength, undefined, length);
-        }
-    }
-    static validateUuid(value) {
-        return uuid.validate(value);
-    }
-    serialize() {
-        return this.asBase64Guid;
-    }
-    static hydrate(value) {
-        return GuidBuffer.withVersion(new GuidBuffer(value));
-    }
-    static LengthMap = {
-        [ecies_lib_1.GuidBrandType.Unknown]: -1,
-        [ecies_lib_1.GuidBrandType.FullHexGuid]: 36,
-        [ecies_lib_1.GuidBrandType.ShortHexGuid]: 32,
-        [ecies_lib_1.GuidBrandType.Base64Guid]: 24,
-        [ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer]: 16,
-        [ecies_lib_1.GuidBrandType.BigIntGuid]: -1, // Variable length
-    };
-    static ReverseLengthMap = {
-        0: ecies_lib_1.GuidBrandType.Unknown,
-        36: ecies_lib_1.GuidBrandType.FullHexGuid,
-        32: ecies_lib_1.GuidBrandType.ShortHexGuid,
-        24: ecies_lib_1.GuidBrandType.Base64Guid,
-        16: ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer,
-        // BigIntGuid is variable length, so it is not included in the reverse map
-    };
-    static VerifyFunctions = {
-        [ecies_lib_1.GuidBrandType.Unknown]: () => false,
-        [ecies_lib_1.GuidBrandType.FullHexGuid]: (guid) => this.isFullHexGuid(guid),
-        [ecies_lib_1.GuidBrandType.ShortHexGuid]: (guid) => this.isShortHexGuid(guid),
-        [ecies_lib_1.GuidBrandType.Base64Guid]: (guid) => this.isBase64Guid(guid),
-        [ecies_lib_1.GuidBrandType.BigIntGuid]: (guid) => this.isBigIntGuid(guid),
-        [ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer]: (guid) => this.isRawGuidPlatformBuffer(guid),
-    };
-    /**
-     * Returns the GUID as a raw Buffer.
-     * NOTE: Returns a defensive copy to prevent external mutation.
-     * Use asRawGuidPlatformBufferUnsafe() if you need the internal buffer and guarantee no mutation.
-     */
-    get asRawGuidPlatformBuffer() {
-        return Buffer.from(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.
-     * @internal
-     */
-    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
-     */
-    static generate() {
-        try {
-            const uuidStr = uuid.v4();
-            if (!uuidStr) {
-                throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-            }
-            return GuidBuffer.withVersion(new GuidBuffer(uuidStr));
-        }
-        catch (error) {
-            if (error instanceof ecies_lib_1.GuidError) {
-                throw error;
-            }
-            throw new ecies_lib_1.GuidError(ecies_lib_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 GuidBuffer.generate();
-    }
-    /**
-     * Alias for generate() for backward compatibility.
-     * @deprecated Use generate() instead for clearer intent
-     */
-    static new() {
-        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 with __version attached
-     * @throws {GuidError} If the value is not a valid GUID
-     */
-    static parse(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 with __version attached, or null if parsing fails
-     */
-    static tryParse(value) {
-        try {
-            return GuidBuffer.withVersion(new GuidBuffer(value));
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Validates whether a value is a valid GUID without creating an instance.
-     * More efficient than tryParse when you only need validation.
-     * @param value The value to validate
-     * @returns True if valid, false otherwise
-     */
-    static isValid(value) {
-        if (!value)
-            return false;
-        try {
-            const guid = new GuidBuffer(value);
-            return guid.isValidV4();
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Factory method to create a GUID from a full hex string.
-     * @param fullHex The full hex string (with dashes)
-     * @returns A new Guid instance with __version attached
-     */
-    static fromFullHex(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 with __version attached
-     */
-    static fromShortHex(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 with __version attached
-     */
-    static fromBase64(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 with __version attached
-     */
-    static fromBigInt(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 with __version attached
-     */
-    static fromBuffer(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 with __version attached
-     */
-    static fromUint8Array(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 with __version attached
-     * @example
-     * const guid = Guid.v3('example.com', uuid.v3.DNS);
-     */
-    static v3(name, namespace) {
-        try {
-            const namespaceStr = Buffer.isBuffer(namespace)
-                ? GuidBuffer.toFullHexGuid(namespace.toString('hex'))
-                : namespace;
-            const v3Guid = uuid.v3(name, namespaceStr);
-            return GuidBuffer.withVersion(new GuidBuffer(v3Guid));
-        }
-        catch (error) {
-            if (error instanceof ecies_lib_1.GuidError) {
-                throw error;
-            }
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
-    }
-    /**
-     * 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 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)
-                ? GuidBuffer.toFullHexGuid(namespace.toString('hex'))
-                : namespace;
-            const v5Guid = uuid.v5(name, namespaceStr);
-            return GuidBuffer.withVersion(new GuidBuffer(v5Guid));
-        }
-        catch (error) {
-            if (error instanceof ecies_lib_1.GuidError) {
-                throw error;
-            }
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
-    }
-    /**
-     * Common namespace constants for use with v3/v5 GUIDs.
-     * These are the standard RFC 4122 namespace UUIDs, defined inline for browser compatibility.
-     * (Avoids issues with uuid library's namespace exports in some bundler configurations)
-     */
-    static Namespaces = {
-        /** DNS namespace UUID per RFC 4122 */
-        DNS: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
-        /** URL namespace UUID per RFC 4122 */
-        URL: '6ba7b811-9dad-11d1-80b4-00c04fd430c8',
-    };
-    /**
-     * Returns the GUID as a full hex string.
-     * Result is cached for performance.
-     */
-    get asFullHexGuid() {
-        if (!this._cachedFullHex) {
-            const hexString = this._value.toString('hex');
-            this._cachedFullHex = GuidBuffer.toFullHexGuid(hexString);
-        }
-        return this._cachedFullHex;
     }
     /**
      * Returns the GUID as a raw Buffer.
      */
     get asBuffer() {
-        return this._value;
+        return Buffer.isBuffer(this._value)
+            ? this._value
+            : Buffer.from(this._value);
     }
     /**
      * Returns the GUID as a native Uint8Array (not a Buffer).
@@ -437,672 +38,96 @@ class GuidBuffer {
     get asUint8Array() {
         return new Uint8Array(this._value);
     }
-    /**
-     * Returns the GUID as a short hex string.
-     * Result is cached for performance.
-     */
-    get asShortHexGuid() {
-        if (!this._cachedShortHex) {
-            this._cachedShortHex = GuidBuffer.toShortHexGuid(this.asFullHexGuid);
-        }
-        return this._cachedShortHex;
+    get asPlatformBuffer() {
+        return Buffer.isBuffer(this._value)
+            ? this._value
+            : Buffer.from(this._value);
     }
     /**
-     * Returns the GUID as a base64 string.
+     * Factory method to create a GUID from a raw buffer.
      */
-    toString() {
-        return this.asBase64Guid;
+    static fromBuffer(buffer) {
+        return GuidBuffer.parse(buffer);
     }
     /**
-     * Returns the GUID as a JSON string.
-     * @returns The GUID as a JSON string.
+     * Factory method to create a GUID from a raw Uint8Array.
      */
-    toJson() {
-        return JSON.stringify(this.asBase64Guid);
+    static fromUint8Array(bytes) {
+        return GuidBuffer.parse(Buffer.from(bytes));
     }
     /**
-     * Returns the GUID as a bigint.
+     * Alias for isRawGuidPlatformBuffer for backward compatibility
      */
-    get asBigIntGuid() {
-        return BigInt('0x' + this._value.toString('hex'));
-    }
+    static isRawGuidBuffer = ecies_lib_1.GuidUint8Array.isRawGuidUint8Array;
     /**
-     * Returns the GUID as a base64 string.
-     * Result is cached for performance.
+     * Converts a GUID input to a raw Buffer (Node.js specific).
      */
-    get asBase64Guid() {
-        if (!this._cachedBase64) {
-            this._cachedBase64 = this._value.toString('base64');
-        }
-        return this._cachedBase64;
-    }
-    get asPlatformBuffer() {
-        return this._value;
+    static toRawGuidBuffer(value) {
+        const uint8 = ecies_lib_1.GuidUint8Array.toRawGuidPlatformBuffer(value);
+        return Buffer.from(uint8);
     }
     /**
-     * Checks if a GUID value is a boundary value (all zeros or all Fs).
-     * @param value The GUID value to check.
-     * @returns True if the value is a boundary value.
+     * Attaches the RFC 4122 version to a GuidBuffer instance.
      */
-    static isBoundaryValue(value) {
-        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);
+    static attachVersion(guid) {
+        const version = guid.getVersion();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        guid.__version = version;
+        return guid;
     }
-    /**
-     * Verifies if a given GUID is valid for the given brand.
-     * @param guidBrand The brand of the GUID to verify.
-     * @param guid The GUID to verify.
-     * @returns True if the GUID is valid for the given brand, false otherwise.
-     */
-    static verifyGuid(guidBrand, guid) {
-        if (guid === null || guid === undefined) {
-            return false;
-        }
-        try {
-            const verifyFunc = GuidBuffer.VerifyFunctions[guidBrand];
-            return verifyFunc(guid);
-        }
-        catch {
-            return false;
-        }
+    static v4() {
+        return GuidBuffer.attachVersion(new GuidBuffer(ecies_lib_1.GuidUint8Array.v4().asFullHexGuid));
     }
-    /**
-     * Returns the length of the GUID for the given brand.
-     * @param guidBrand The brand of the GUID to get the length for.
-     * @returns The length of the GUID for the given brand.
-     */
-    static guidBrandToLength(guidBrand) {
-        const length = GuidBuffer.LengthMap[guidBrand];
-        if (length <= 0) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownBrand, guidBrand);
-        }
-        return length;
+    static v5(name, namespace) {
+        return GuidBuffer.attachVersion(new GuidBuffer(ecies_lib_1.GuidUint8Array.v5(name, namespace).asFullHexGuid));
     }
-    /**
-     * 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.
-     * @returns The brand of the GUID for the given length.
-     */
-    static lengthToGuidBrand(length, isBuffer) {
-        if (length <= 0) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownLength, undefined, 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);
-        }
-        // Validate buffer vs string type consistency
-        const isBrandBuffer = brand === ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer;
-        if (isBuffer !== isBrandBuffer) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownLength, brand, length);
-        }
-        return brand;
+    static v3(name, namespace) {
+        return GuidBuffer.attachVersion(new GuidBuffer(ecies_lib_1.GuidUint8Array.v3(name, namespace).asFullHexGuid));
     }
-    /**
-     * Verifies if a given GUID is a valid full hex GUID.
-     * @param fullHexGuidValue The full hex GUID to verify.
-     * @returns True if the GUID is a valid full hex GUID, false otherwise.
-     */
-    static isFullHexGuid(fullHexGuidValue) {
-        try {
-            if (fullHexGuidValue === null || fullHexGuidValue === undefined) {
-                return false;
-            }
-            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 (GuidBuffer.isBoundaryValue(strValue)) {
-                return true;
-            }
-            return GuidBuffer.validateUuid(strValue);
-        }
-        catch {
-            return false;
-        }
+    static v6(options) {
+        return GuidBuffer.attachVersion(new GuidBuffer(ecies_lib_1.GuidUint8Array.v6(options).asFullHexGuid));
     }
-    /**
-     * Verifies if a given GUID is a valid short hex GUID.
-     * @param shortHexGuidValue The short hex GUID to verify.
-     * @returns True if the GUID is a valid short hex GUID, false otherwise.
-     */
-    static isShortHexGuid(shortHexGuidValue) {
-        try {
-            if (shortHexGuidValue === null || shortHexGuidValue === undefined) {
-                return false;
-            }
-            const expectedLength = GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid);
-            const strValue = String(shortHexGuidValue);
-            if (strValue.length !== expectedLength) {
-                return false;
-            }
-            try {
-                const fullHexGuid = GuidBuffer.toFullHexGuid(strValue);
-                // Boundary values are always valid
-                if (GuidBuffer.isBoundaryValue(fullHexGuid)) {
-                    return true;
-                }
-                return uuid.validate(fullHexGuid);
-            }
-            catch {
-                return false;
-            }
-        }
-        catch {
-            return false;
-        }
+    static v7(options) {
+        return GuidBuffer.attachVersion(new GuidBuffer(ecies_lib_1.GuidUint8Array.v7(options).asFullHexGuid));
     }
-    /**
-     * Verifies if a given GUID is a valid base64 GUID.
-     * @param value The base64 GUID to verify.
-     * @returns True if the GUID is a valid base64 GUID, false otherwise.
-     */
-    static isBase64Guid(value) {
-        try {
-            if (value === null || value === undefined) {
-                return false;
-            }
-            let valueLength;
-            if (typeof value === 'bigint') {
-                valueLength = value.toString(16).length;
-            }
-            else if (GuidBuffer.isBufferLike(value)) {
-                valueLength = value.length;
-            }
-            else {
-                valueLength = String(value).length;
-            }
-            const result = valueLength === GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid);
-            if (result) {
-                try {
-                    const fromBase64 = GuidBuffer.toRawGuidPlatformBuffer(value);
-                    const hexString = fromBase64.toString('hex');
-                    const fullHexGuid = GuidBuffer.toFullHexGuid(hexString);
-                    // Boundary values are always valid
-                    if (GuidBuffer.isBoundaryValue(fullHexGuid)) {
-                        return true;
-                    }
-                    return uuid.validate(fullHexGuid);
-                }
-                catch {
-                    return false;
-                }
-            }
-            return result;
-        }
-        catch {
-            return false;
-        }
+    static v1(options) {
+        return GuidBuffer.attachVersion(new GuidBuffer(ecies_lib_1.GuidUint8Array.v1(options).asFullHexGuid));
     }
-    /**
-     * 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.
-     */
-    static isRawGuidPlatformBuffer(value) {
-        try {
-            if (value === null || value === undefined) {
-                return false;
-            }
-            const expectedLength = GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer);
-            let valueLength;
-            if (typeof value === 'bigint') {
-                valueLength = value.toString(16).length;
-            }
-            else if (GuidBuffer.isBufferLike(value)) {
-                valueLength = value.length;
-            }
-            else {
-                valueLength = String(value).length;
-            }
-            if (valueLength !== expectedLength) {
-                return false;
-            }
-            try {
-                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 = GuidBuffer.toFullHexGuid(hexString);
-                // Boundary values are always valid
-                if (GuidBuffer.isBoundaryValue(fullHexGuid)) {
-                    return true;
-                }
-                return GuidBuffer.validateUuid(fullHexGuid);
-            }
-            catch {
-                return false;
-            }
-        }
-        catch {
-            return false;
-        }
+    static parse(value) {
+        return GuidBuffer.attachVersion(new GuidBuffer(value));
     }
-    /**
-     * Verifies if a given GUID is a valid bigint GUID.
-     * @param value The bigint GUID to verify.
-     * @returns True if the GUID is a valid bigint GUID, false otherwise.
-     */
-    static isBigIntGuid(value) {
+    static tryParse(value) {
         try {
-            if (value === null || value === undefined) {
-                return false;
-            }
-            if (typeof value !== 'bigint') {
-                return false;
-            }
-            if (value < 0n || value > GuidBuffer.MAX_BIGINT_VALUE) {
-                return false;
-            }
-            try {
-                const fromBigInt = GuidBuffer.toFullHexFromBigInt(value);
-                // Boundary values are always valid
-                if (GuidBuffer.isBoundaryValue(fromBigInt)) {
-                    return true;
-                }
-                return uuid.validate(fromBigInt);
-            }
-            catch {
-                return false;
-            }
+            return GuidBuffer.attachVersion(new GuidBuffer(value));
         }
         catch {
-            return false;
-        }
-    }
-    /**
-     * Determines the brand of a given GUID value.
-     * @param value The GUID value to determine the brand of.
-     * @returns The brand of the GUID value.
-     */
-    static whichBrand(value) {
-        if (value === null || value === undefined) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
-        if (typeof value === 'bigint') {
-            return ecies_lib_1.GuidBrandType.BigIntGuid;
+            return null;
         }
-        const isBuffer = GuidBuffer.isBufferLike(value);
-        const expectedLength = isBuffer
-            ? value.length
-            : String(value).length;
-        return GuidBuffer.lengthToGuidBrand(expectedLength, isBuffer);
     }
-    /**
-     * Converts a given short hex GUID to a full hex GUID.
-     * @param shortGuid The short hex GUID to convert.
-     * @returns The short hex GUID as a full hex GUID.
-     */
-    static shortGuidToFullGuid(shortGuid) {
-        // insert dashes
-        const str = shortGuid.replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '$1-$2-$3-$4-$5');
-        return str;
-    }
-    /**
-     * Converts a given GUID value to a full hex GUID.
-     * @param guid The GUID value to convert.
-     * @returns The GUID value as a full hex GUID.
-     */
-    static toFullHexGuid(guid) {
-        if (guid === null || guid === undefined) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
-        if (typeof guid === 'bigint') {
-            return GuidBuffer.toFullHexFromBigInt(guid);
-        }
-        else if (GuidBuffer.isBufferLike(guid) &&
-            guid.length ===
-                GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
-            const hexString = guid.toString('hex');
-            const shortHex = hexString;
-            return GuidBuffer.shortGuidToFullGuid(shortHex);
-        }
-        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 ===
-            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid)) {
-            // short hex guid
-            return GuidBuffer.shortGuidToFullGuid(strValue);
-        }
-        else if (strValue.length ===
-            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid)) {
-            // already a full hex guid
-            return strValue;
-        }
-        else if (strValue.length === GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid)) {
-            // base64 guid
-            const shortGuid = Buffer.from(strValue, 'base64').toString('hex');
-            return GuidBuffer.shortGuidToFullGuid(shortGuid);
-        }
-        else {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
+    static generate() {
+        return GuidBuffer.v4();
     }
-    static toShortHexGuid(guid) {
-        if (guid === null || guid === undefined) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
-        if (typeof guid === 'bigint') {
-            const fullHex = GuidBuffer.toFullHexFromBigInt(guid);
-            return fullHex.replace(/-/g, '');
-        }
-        else if (GuidBuffer.isBufferLike(guid) &&
-            guid.length ===
-                GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
-            return guid.toString('hex');
-        }
-        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 ===
-            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.ShortHexGuid)) {
-            // already a short hex guid
-            return strValue;
-        }
-        else if (strValue.length ===
-            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.FullHexGuid)) {
-            // full hex guid
-            return strValue.replace(/-/g, '');
-        }
-        else if (strValue.length === GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.Base64Guid)) {
-            // base64 guid
-            return Buffer.from(strValue, 'base64').toString('hex');
-        }
-        else {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
+    static new() {
+        return GuidBuffer.v4();
     }
-    /**
-     * Converts a given bigint to a full hex GUID.
-     * @param bigInt The bigint to convert.
-     * @returns The bigint as a full hex GUID.
-     */
-    static toFullHexFromBigInt(bigInt) {
-        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');
-        // After padding, should always be exactly 32 characters
-        if (uuidBigInt.length !== 32) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-        }
-        const rebuiltUuid = uuidBigInt.slice(0, 8) +
-            '-' +
-            uuidBigInt.slice(8, 12) +
-            '-' +
-            uuidBigInt.slice(12, 16) +
-            '-' +
-            uuidBigInt.slice(16, 20) +
-            '-' +
-            uuidBigInt.slice(20);
-        return rebuiltUuid;
+    static fromFullHex(fullHex) {
+        return GuidBuffer.attachVersion(new GuidBuffer(fullHex));
     }
-    /**
-     * Converts a given GUID value to a raw GUID buffer.
-     * @param value The GUID value to convert.
-     * @returns The GUID value as a raw GUID buffer.
-     */
-    static toRawGuidPlatformBuffer(value) {
-        const expectedBrand = GuidBuffer.whichBrand(value);
-        let rawGuidBufferResult = Buffer.alloc(0);
-        switch (expectedBrand) {
-            case ecies_lib_1.GuidBrandType.FullHexGuid:
-                rawGuidBufferResult = Buffer.from(GuidBuffer.toShortHexGuid(value), 'hex');
-                break;
-            case ecies_lib_1.GuidBrandType.ShortHexGuid:
-                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
-                if (typeof value === 'string' || Buffer.isBuffer(value)) {
-                    rawGuidBufferResult = Buffer.from(value.toString(), 'base64');
-                }
-                else {
-                    throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-                }
-                break;
-            case ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer:
-                // Convert Uint8Array to Buffer if needed
-                if (Buffer.isBuffer(value)) {
-                    rawGuidBufferResult = value;
-                }
-                else if (value instanceof Uint8Array) {
-                    rawGuidBufferResult = Buffer.from(value);
-                }
-                else {
-                    throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuid);
-                }
-                break;
-            case ecies_lib_1.GuidBrandType.BigIntGuid:
-                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 !==
-            GuidBuffer.guidBrandToLength(ecies_lib_1.GuidBrandType.RawGuidPlatformBuffer)) {
-            throw new ecies_lib_1.GuidError(ecies_lib_1.GuidErrorType.InvalidGuidUnknownLength, undefined, rawGuidBufferResult.length);
-        }
-        return rawGuidBufferResult;
+    static fromShortHex(shortHex) {
+        return GuidBuffer.attachVersion(new GuidBuffer(shortHex));
     }
-    /**
-     * 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 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.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.compare(this.asRawGuidPlatformBufferUnsafe, other.asRawGuidPlatformBuffer) === 0);
+    static fromBase64(base64) {
+        return GuidBuffer.attachVersion(new GuidBuffer(base64));
     }
-    /**
-     * Checks if this GUID is empty (all zeros).
-     * @returns True if the GUID is all zeros, false otherwise
-     */
-    isEmpty() {
-        // Check if all bytes are zero
-        for (let i = 0; i < this._value.length; i++) {
-            if (this._value[i] !== 0) {
-                return false;
-            }
-        }
-        return true;
+    static fromBigInt(bigint) {
+        return GuidBuffer.attachVersion(new GuidBuffer(bigint));
     }
-    /**
-     * Static helper to check if a GUID is null, undefined, or empty.
-     * @param guid The GUID to check
-     * @returns True if the GUID is null, undefined, or empty
-     */
-    static isNilOrEmpty(guid) {
-        return !guid || (guid instanceof GuidBuffer && guid.isEmpty());
+    static fromPlatformBuffer(bytes) {
+        return GuidBuffer.attachVersion(new GuidBuffer(bytes));
     }
-    /**
-     * Creates a new Guid instance with the same value as this one.
-     * @returns A new Guid instance with identical value and __version attached
-     */
     clone() {
-        return GuidBuffer.withVersion(new GuidBuffer(Buffer.from(this._value)));
-    }
-    /**
-     * Returns the hash code for this GUID based on its buffer content.
-     * Useful for using GUIDs as Map/Set keys.
-     * @returns A numeric hash code
-     */
-    hashCode() {
-        let hash = 0;
-        for (let i = 0; i < this._value.length; i++) {
-            hash = (hash << 5) - hash + this._value[i];
-            hash = hash & hash; // Convert to 32-bit integer
-        }
-        return hash;
-    }
-    /**
-     * Extracts the RFC 4122 version from the GUID.
-     * Returns undefined for boundary values or invalid GUIDs.
-     * @returns The version number (1-5) or undefined
-     */
-    getVersion() {
-        // Skip boundary values
-        if (GuidBuffer.isBoundaryValue(this.asFullHexGuid)) {
-            return undefined;
-        }
-        // Version is in bits 48-51 (byte 6, high nibble)
-        const versionByte = this._value[6];
-        const version = (versionByte >> 4) & 0x0f;
-        // 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.
-     * @returns True if valid v4 GUID or boundary value, false otherwise
-     */
-    isValidV4() {
-        // Boundary values are considered valid
-        if (GuidBuffer.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;
+        return GuidBuffer.attachVersion(new GuidBuffer(Buffer.from(this._value)));
     }
-    /**
-     * 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.
-     * @param other The other GUID to compare to
-     * @returns -1 if this < other, 0 if equal, 1 if this > other
-     */
-    compareTo(other) {
-        return Buffer.compare(this.asRawGuidPlatformBufferUnsafe, other.asRawGuidPlatformBuffer);
-    }
-    /**
-     * 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 with __version attached
-     */
-    static v1() {
-        try {
-            const v1Guid = uuid.v1();
-            return GuidBuffer.withVersion(new GuidBuffer(v1Guid));
-        }
-        catch (error) {
-            if (error instanceof ecies_lib_1.GuidError)
-                throw error;
-            throw new ecies_lib_1.GuidError(ecies_lib_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() {
-        return this._value
-            .toString('base64')
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=/g, '');
-    }
-    /**
-     * 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 GuidBuffer.withVersion(new GuidBuffer(base64));
-    }
-    /**
-     * Alias for isRawGuidPlatformBuffer for backward compatibility
-     */
-    static isRawGuidBuffer = GuidBuffer.isRawGuidPlatformBuffer;
-    /**
-     * Alias for toRawGuidPlatformBuffer for backward compatibility
-     */
-    static toRawGuidBuffer = GuidBuffer.toRawGuidPlatformBuffer;
 }
 exports.GuidBuffer = GuidBuffer;
 //# sourceMappingURL=guid.js.map