@powfix/core-js 0.22.0 → 0.22.1

package/dist/index.node.cjs

@@ -76137,8 +76137,323 @@ var Validator2 = import_index2.default.Validator;
 var ValidationErrorItemOrigin = import_index2.default.ValidationErrorItemOrigin;
 var ValidationErrorItemType = import_index2.default.ValidationErrorItemType;
 
+// node_modules/@powfix/uuid/dist/index.node.js
+var Uint8ArrayUtils2 = class {
+  static fromHex(hex) {
+    return Uint8Array.from(hex.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? []);
+  }
+  static toHex(bytes) {
+    return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+  }
+};
+var UUID2 = class _UUID {
+  /* --------------------------------------------------------------------
+   * Regular expressions used to validate UUIDs in different string forms
+   * -------------------------------------------------------------------- */
+  /** Matches a 32‑character hexadecimal representation of a UUID without hyphens. */
+  static REGEX_HEX = /^[0-9a-fA-F]{8}[0-9a-fA-F]{4}[1-5][0-9a-fA-F]{3}[89abAB][0-9a-fA-F]{3}[0-9a-fA-F]{12}$/;
+  /** Matches the RFC 4122 canonical UUID format with hyphens. */
+  static REGEX_RFC4122 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+  /* --------------------------------------------------------------------
+   * Constant lengths used throughout the class
+   * -------------------------------------------------------------------- */
+  /** Number of bytes that represent a UUID. */
+  static BYTE_LENGTH = 16;
+  /** Total length of an RFC 4122 UUID string (including hyphens). */
+  static STR_LENGTH = 36;
+  /** Length of a UUID represented as a plain hexadecimal string. */
+  static HEX_STR_LENGTH = 32;
+  /* --------------------------------------------------------------------
+   * Validation helpers
+   * -------------------------------------------------------------------- */
+  /**
+   * Checks if the supplied value is a valid hex representation of a UUID.
+   * @param hex - The string to validate.
+   * @returns true if the string matches {@link REGEX_HEX}.
+   */
+  static isValidHex(hex) {
+    if (typeof hex !== "string") {
+      return false;
+    }
+    return _UUID.REGEX_HEX.test(hex);
+  }
+  /**
+   * Checks if the supplied value is a valid RFC 4122 UUID string.
+   * @param str - The string to validate.
+   * @returns true if the string matches {@link REGEX_RFC4122}.
+   */
+  static isValidString(str) {
+    if (typeof str !== "string") {
+      return false;
+    }
+    return _UUID.REGEX_RFC4122.test(str);
+  }
+  /**
+   * Checks whether an ArrayBufferView contains exactly {@link BYTE_LENGTH} bytes.
+   * @param bytes - The view to check.
+   * @returns true if the byte length is correct.
+   */
+  static isValidBytes(bytes) {
+    return bytes.byteLength === _UUID.BYTE_LENGTH;
+  }
+  /**
+   * Generic validation that accepts either a string (hex or RFC 4122 format)
+   * or an ArrayBufferView containing the raw bytes.
+   * @param input - The value to validate.
+   * @returns true if the input is a valid representation of a UUID.
+   */
+  static isValid(input) {
+    if (typeof input === "string") {
+      const length = input.length;
+      switch (length) {
+        case _UUID.STR_LENGTH:
+          return _UUID.isValidString(input);
+        case _UUID.HEX_STR_LENGTH:
+          return _UUID.isValidHex(input);
+        default:
+          return false;
+      }
+    } else if (input instanceof _UUID) {
+      return _UUID.isValidBytes(input.bytes);
+    } else if (ArrayBuffer.isView(input)) {
+      return _UUID.isValidBytes(input);
+    } else {
+      return false;
+    }
+  }
+  static version(input) {
+    return this.parse(input)[6] >> 4 & 15;
+  }
+  /* --------------------------------------------------------------------
+   * Parsing / formatting helpers
+   * -------------------------------------------------------------------- */
+  /**
+   * Inserts hyphens into a 32‑character hex string to produce an RFC 4122 string.
+   * @param hex - The plain hexadecimal UUID.
+   * @returns The formatted RFC 4122 string.
+   */
+  static formatHex(hex) {
+    if (hex.length !== _UUID.HEX_STR_LENGTH) {
+      throw new Error(`hex length should be ${_UUID.HEX_STR_LENGTH}`);
+    }
+    return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20);
+  }
+  /** Removes all hyphens from a UUID string. */
+  static stripHyphens(str) {
+    return str.replace(/-/g, "");
+  }
+  /**
+   * Converts a plain hexadecimal UUID into a Uint8Array.
+   * @param hex - The hex string to parse.
+   * @returns A Uint8Array containing the raw bytes.
+   */
+  static parseHex(hex) {
+    if (hex.length !== _UUID.HEX_STR_LENGTH) {
+      throw new Error(`Invalid hex string, length should be ${_UUID.HEX_STR_LENGTH}`);
+    }
+    return Uint8ArrayUtils2.fromHex(hex);
+  }
+  /**
+   * Parses an RFC 4122 string into a Uint8Array.
+   * @param str - The formatted UUID string.
+   * @returns A Uint8Array containing the raw bytes.
+   */
+  static parseString(str) {
+    if (str.length !== _UUID.STR_LENGTH) {
+      throw new Error(`Invalid UUID string, invalid character length should be ${_UUID.STR_LENGTH}`);
+    }
+    if (!_UUID.isValid(str)) {
+      throw new Error("Invalid UUID string, should be RFC 4122 format");
+    }
+    const hex = _UUID.stripHyphens(str);
+    if (hex.length !== _UUID.HEX_STR_LENGTH) {
+      throw new Error("Invalid UUID string, invalid character length after strip hyphens");
+    }
+    return Uint8ArrayUtils2.fromHex(hex);
+  }
+  /**
+   * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
+   * @param bytes - The view to parse.
+   * @returns A Uint8Array containing the raw bytes.
+   */
+  static parseBytes(bytes) {
+    const view = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.length !== _UUID.BYTE_LENGTH) {
+      throw new Error(`Expected ${_UUID.BYTE_LENGTH} bytes`);
+    }
+    return new Uint8Array(view);
+  }
+  /* --------------------------------------------------------------------
+   * Factory methods
+   * -------------------------------------------------------------------- */
+  /**
+   * Creates a UUID instance from a plain hexadecimal string.
+   * @param hex - The hex representation of the UUID.
+   * @returns A new {@link UUID} object.
+   */
+  static fromHex(hex) {
+    return new this(this.parseHex(hex));
+  }
+  /**
+   * Creates a UUID instance from an RFC 4122 formatted string.
+   * @param str - The UUID string with hyphens.
+   * @returns A new {@link UUID} object.
+   */
+  static fromString(str) {
+    return new this(this.parseString(str));
+  }
+  /**
+   * Creates a UUID instance from raw bytes.
+   * @param bytes - An ArrayBufferView containing 16 bytes.
+   * @returns A new {@link UUID} object.
+   */
+  static fromBytes(bytes) {
+    return new this(this.parseBytes(bytes));
+  }
+  /**
+   * Parses any supported input (string or bytes) and returns the raw byte array.
+   * @param input - The value to parse.
+   * @returns A Uint8Array of length {@link BYTE_LENGTH}.
+   */
+  static parse(input) {
+    if (typeof input === "string") {
+      const length = input.length;
+      switch (length) {
+        case _UUID.STR_LENGTH:
+          return this.parseString(input);
+        case _UUID.HEX_STR_LENGTH:
+          return this.parseHex(input);
+        default:
+          throw new Error(`Invalid input string, length should be ${_UUID.STR_LENGTH} or ${_UUID.HEX_STR_LENGTH}`);
+      }
+    } else if (input instanceof _UUID) {
+      return input.toBytes();
+    } else if (ArrayBuffer.isView(input)) {
+      return this.parseBytes(input);
+    } else {
+      throw new Error("Invalid input, Expected string or ArrayBufferView");
+    }
+  }
+  /**
+   * Creates a UUID from any supported input type.
+   * @param input - The value to parse.
+   * @returns A new {@link UUID} object.
+   */
+  static from(input) {
+    return this.fromBytes(_UUID.parse(input));
+  }
+  /** Returns the nil (all zero) UUID. */
+  static nil() {
+    return this.fromBytes(new Uint8Array(_UUID.BYTE_LENGTH));
+  }
+  /** Returns a UUID consisting of all 0xFF bytes. */
+  static max() {
+    return this.fromBytes(new Uint8Array(_UUID.BYTE_LENGTH).fill(255));
+  }
+  /* --------------------------------------------------------------------
+   * Equality / comparison
+   * -------------------------------------------------------------------- */
+  /**
+   * Compares multiple UUIDs for strict equality.
+   * @param inputs - The UUIDs to compare (at least two required).
+   * @returns true if all provided UUIDs are identical.
+   */
+  static equals(...inputs) {
+    const n = inputs.length;
+    if (n < 2) {
+      throw new Error("At least two UUIDs required for comparison");
+    }
+    const ref = this.parse(inputs[0]);
+    for (let i = 1; i < n; ++i) {
+      const b = this.parse(inputs[i]);
+      for (let j = 0; j < _UUID.BYTE_LENGTH; ++j) {
+        if (ref[j] !== b[j]) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Lexicographically compares two UUIDs.
+   * @param uuid1 - The first UUID.
+   * @param uuid2 - The second UUID.
+   * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
+   */
+  static compare(uuid1, uuid2) {
+    const a = this.parse(uuid1);
+    const b = this.parse(uuid2);
+    for (let i = 0; i < _UUID.BYTE_LENGTH; i++) {
+      if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;
+    }
+    return 0;
+  }
+  /* --------------------------------------------------------------------
+   * Instance members
+   * -------------------------------------------------------------------- */
+  /** Raw byte representation of the UUID. */
+  bytes;
+  // Cached string and hex representations to avoid recomputation.
+  _str;
+  _hex;
+  /**
+   * Constructs a new {@link UUID} instance from any supported input type.
+   * @param input - The value to parse (string or ArrayBufferView).
+   */
+  constructor(input) {
+    this.bytes = _UUID.parse(input);
+  }
+  /** Instance wrapper for {@link equals}. */
+  equals(...inputs) {
+    return _UUID.equals(this, ...inputs);
+  }
+  /** Instance wrapper for {@link compare}. */
+  compare(other) {
+    return _UUID.compare(this, other);
+  }
+  version() {
+    return _UUID.version(this);
+  }
+  /**
+   * Returns the RFC 4122 string representation of this UUID.
+   * @returns The formatted UUID string.
+   */
+  toString() {
+    if (this._str != null) {
+      return this._str;
+    }
+    const hex = this.toHex();
+    this._str = _UUID.formatHex(hex);
+    return this._str;
+  }
+  /**
+   * Returns the plain hexadecimal representation of this UUID.
+   * @returns A 32‑character hex string.
+   */
+  toHex() {
+    if (this._hex != null) {
+      return this._hex;
+    }
+    this._hex = Uint8ArrayUtils2.toHex(this.bytes);
+    return this._hex;
+  }
+  /**
+   * Returns a copy of the raw byte array.
+   * @returns A new Uint8Array containing the UUID bytes.
+   */
+  toBytes() {
+    return new Uint8Array(this.bytes);
+  }
+  /** JSON serialization helper – returns the RFC 4122 string. */
+  toJSON() {
+    return this.toString();
+  }
+};
+var UUID22 = class extends UUID2 {
+  toBuffer() {
+    return Buffer.from(this.bytes);
+  }
+};
+
 // src/nodejs/utils/sequelize-utils/SequelizeUtils.ts
-var import_node = require("@powfix/uuid/node");
 var SequelizeUtils = class _SequelizeUtils {
   static decimal2Number(value) {
     if (value === null || value === void 0) {
@@ -76156,7 +76471,7 @@ var SequelizeUtils = class _SequelizeUtils {
       allowNull: false,
       primaryKey: true,
       unique: true,
-      defaultValue: () => import_node.UUID.from(UuidUtils.v4()).toBuffer()
+      defaultValue: () => UUID22.from(UuidUtils.v4()).toBuffer()
     })
   });
   static buildUuidColumn(options) {
@@ -76166,10 +76481,10 @@ var SequelizeUtils = class _SequelizeUtils {
         type: "binary(16)",
         get() {
           const value = this.getDataValue(columnName);
-          return value != null ? import_node.UUID.from(value) : value;
+          return value != null ? UUID22.from(value) : value;
         },
         set(input) {
-          const value = input != null ? import_node.UUID.from(input).toBuffer() : input;
+          const value = input != null ? UUID22.from(input).toBuffer() : input;
           this.setDataValue(columnName, value);
         },
         ...overrideOptions
@@ -76179,10 +76494,10 @@ var SequelizeUtils = class _SequelizeUtils {
         type: "binary(16)",
         get() {
           const value = this.getDataValue(columnName);
-          return import_node.UUID.from(value);
+          return UUID22.from(value);
         },
         set(input) {
-          const value = import_node.UUID.from(input).toBuffer();
+          const value = UUID22.from(input).toBuffer();
           this.setDataValue(columnName, value);
         },
         ...overrideOptions

package/dist/index.node.js

@@ -76079,8 +76079,323 @@ var Validator2 = import_index2.default.Validator;
 var ValidationErrorItemOrigin = import_index2.default.ValidationErrorItemOrigin;
 var ValidationErrorItemType = import_index2.default.ValidationErrorItemType;
 
+// node_modules/@powfix/uuid/dist/index.node.js
+var Uint8ArrayUtils2 = class {
+  static fromHex(hex) {
+    return Uint8Array.from(hex.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? []);
+  }
+  static toHex(bytes) {
+    return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+  }
+};
+var UUID2 = class _UUID {
+  /* --------------------------------------------------------------------
+   * Regular expressions used to validate UUIDs in different string forms
+   * -------------------------------------------------------------------- */
+  /** Matches a 32‑character hexadecimal representation of a UUID without hyphens. */
+  static REGEX_HEX = /^[0-9a-fA-F]{8}[0-9a-fA-F]{4}[1-5][0-9a-fA-F]{3}[89abAB][0-9a-fA-F]{3}[0-9a-fA-F]{12}$/;
+  /** Matches the RFC 4122 canonical UUID format with hyphens. */
+  static REGEX_RFC4122 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+  /* --------------------------------------------------------------------
+   * Constant lengths used throughout the class
+   * -------------------------------------------------------------------- */
+  /** Number of bytes that represent a UUID. */
+  static BYTE_LENGTH = 16;
+  /** Total length of an RFC 4122 UUID string (including hyphens). */
+  static STR_LENGTH = 36;
+  /** Length of a UUID represented as a plain hexadecimal string. */
+  static HEX_STR_LENGTH = 32;
+  /* --------------------------------------------------------------------
+   * Validation helpers
+   * -------------------------------------------------------------------- */
+  /**
+   * Checks if the supplied value is a valid hex representation of a UUID.
+   * @param hex - The string to validate.
+   * @returns true if the string matches {@link REGEX_HEX}.
+   */
+  static isValidHex(hex) {
+    if (typeof hex !== "string") {
+      return false;
+    }
+    return _UUID.REGEX_HEX.test(hex);
+  }
+  /**
+   * Checks if the supplied value is a valid RFC 4122 UUID string.
+   * @param str - The string to validate.
+   * @returns true if the string matches {@link REGEX_RFC4122}.
+   */
+  static isValidString(str) {
+    if (typeof str !== "string") {
+      return false;
+    }
+    return _UUID.REGEX_RFC4122.test(str);
+  }
+  /**
+   * Checks whether an ArrayBufferView contains exactly {@link BYTE_LENGTH} bytes.
+   * @param bytes - The view to check.
+   * @returns true if the byte length is correct.
+   */
+  static isValidBytes(bytes) {
+    return bytes.byteLength === _UUID.BYTE_LENGTH;
+  }
+  /**
+   * Generic validation that accepts either a string (hex or RFC 4122 format)
+   * or an ArrayBufferView containing the raw bytes.
+   * @param input - The value to validate.
+   * @returns true if the input is a valid representation of a UUID.
+   */
+  static isValid(input) {
+    if (typeof input === "string") {
+      const length = input.length;
+      switch (length) {
+        case _UUID.STR_LENGTH:
+          return _UUID.isValidString(input);
+        case _UUID.HEX_STR_LENGTH:
+          return _UUID.isValidHex(input);
+        default:
+          return false;
+      }
+    } else if (input instanceof _UUID) {
+      return _UUID.isValidBytes(input.bytes);
+    } else if (ArrayBuffer.isView(input)) {
+      return _UUID.isValidBytes(input);
+    } else {
+      return false;
+    }
+  }
+  static version(input) {
+    return this.parse(input)[6] >> 4 & 15;
+  }
+  /* --------------------------------------------------------------------
+   * Parsing / formatting helpers
+   * -------------------------------------------------------------------- */
+  /**
+   * Inserts hyphens into a 32‑character hex string to produce an RFC 4122 string.
+   * @param hex - The plain hexadecimal UUID.
+   * @returns The formatted RFC 4122 string.
+   */
+  static formatHex(hex) {
+    if (hex.length !== _UUID.HEX_STR_LENGTH) {
+      throw new Error(`hex length should be ${_UUID.HEX_STR_LENGTH}`);
+    }
+    return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20);
+  }
+  /** Removes all hyphens from a UUID string. */
+  static stripHyphens(str) {
+    return str.replace(/-/g, "");
+  }
+  /**
+   * Converts a plain hexadecimal UUID into a Uint8Array.
+   * @param hex - The hex string to parse.
+   * @returns A Uint8Array containing the raw bytes.
+   */
+  static parseHex(hex) {
+    if (hex.length !== _UUID.HEX_STR_LENGTH) {
+      throw new Error(`Invalid hex string, length should be ${_UUID.HEX_STR_LENGTH}`);
+    }
+    return Uint8ArrayUtils2.fromHex(hex);
+  }
+  /**
+   * Parses an RFC 4122 string into a Uint8Array.
+   * @param str - The formatted UUID string.
+   * @returns A Uint8Array containing the raw bytes.
+   */
+  static parseString(str) {
+    if (str.length !== _UUID.STR_LENGTH) {
+      throw new Error(`Invalid UUID string, invalid character length should be ${_UUID.STR_LENGTH}`);
+    }
+    if (!_UUID.isValid(str)) {
+      throw new Error("Invalid UUID string, should be RFC 4122 format");
+    }
+    const hex = _UUID.stripHyphens(str);
+    if (hex.length !== _UUID.HEX_STR_LENGTH) {
+      throw new Error("Invalid UUID string, invalid character length after strip hyphens");
+    }
+    return Uint8ArrayUtils2.fromHex(hex);
+  }
+  /**
+   * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
+   * @param bytes - The view to parse.
+   * @returns A Uint8Array containing the raw bytes.
+   */
+  static parseBytes(bytes) {
+    const view = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.length !== _UUID.BYTE_LENGTH) {
+      throw new Error(`Expected ${_UUID.BYTE_LENGTH} bytes`);
+    }
+    return new Uint8Array(view);
+  }
+  /* --------------------------------------------------------------------
+   * Factory methods
+   * -------------------------------------------------------------------- */
+  /**
+   * Creates a UUID instance from a plain hexadecimal string.
+   * @param hex - The hex representation of the UUID.
+   * @returns A new {@link UUID} object.
+   */
+  static fromHex(hex) {
+    return new this(this.parseHex(hex));
+  }
+  /**
+   * Creates a UUID instance from an RFC 4122 formatted string.
+   * @param str - The UUID string with hyphens.
+   * @returns A new {@link UUID} object.
+   */
+  static fromString(str) {
+    return new this(this.parseString(str));
+  }
+  /**
+   * Creates a UUID instance from raw bytes.
+   * @param bytes - An ArrayBufferView containing 16 bytes.
+   * @returns A new {@link UUID} object.
+   */
+  static fromBytes(bytes) {
+    return new this(this.parseBytes(bytes));
+  }
+  /**
+   * Parses any supported input (string or bytes) and returns the raw byte array.
+   * @param input - The value to parse.
+   * @returns A Uint8Array of length {@link BYTE_LENGTH}.
+   */
+  static parse(input) {
+    if (typeof input === "string") {
+      const length = input.length;
+      switch (length) {
+        case _UUID.STR_LENGTH:
+          return this.parseString(input);
+        case _UUID.HEX_STR_LENGTH:
+          return this.parseHex(input);
+        default:
+          throw new Error(`Invalid input string, length should be ${_UUID.STR_LENGTH} or ${_UUID.HEX_STR_LENGTH}`);
+      }
+    } else if (input instanceof _UUID) {
+      return input.toBytes();
+    } else if (ArrayBuffer.isView(input)) {
+      return this.parseBytes(input);
+    } else {
+      throw new Error("Invalid input, Expected string or ArrayBufferView");
+    }
+  }
+  /**
+   * Creates a UUID from any supported input type.
+   * @param input - The value to parse.
+   * @returns A new {@link UUID} object.
+   */
+  static from(input) {
+    return this.fromBytes(_UUID.parse(input));
+  }
+  /** Returns the nil (all zero) UUID. */
+  static nil() {
+    return this.fromBytes(new Uint8Array(_UUID.BYTE_LENGTH));
+  }
+  /** Returns a UUID consisting of all 0xFF bytes. */
+  static max() {
+    return this.fromBytes(new Uint8Array(_UUID.BYTE_LENGTH).fill(255));
+  }
+  /* --------------------------------------------------------------------
+   * Equality / comparison
+   * -------------------------------------------------------------------- */
+  /**
+   * Compares multiple UUIDs for strict equality.
+   * @param inputs - The UUIDs to compare (at least two required).
+   * @returns true if all provided UUIDs are identical.
+   */
+  static equals(...inputs) {
+    const n = inputs.length;
+    if (n < 2) {
+      throw new Error("At least two UUIDs required for comparison");
+    }
+    const ref = this.parse(inputs[0]);
+    for (let i = 1; i < n; ++i) {
+      const b = this.parse(inputs[i]);
+      for (let j = 0; j < _UUID.BYTE_LENGTH; ++j) {
+        if (ref[j] !== b[j]) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Lexicographically compares two UUIDs.
+   * @param uuid1 - The first UUID.
+   * @param uuid2 - The second UUID.
+   * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
+   */
+  static compare(uuid1, uuid2) {
+    const a = this.parse(uuid1);
+    const b = this.parse(uuid2);
+    for (let i = 0; i < _UUID.BYTE_LENGTH; i++) {
+      if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;
+    }
+    return 0;
+  }
+  /* --------------------------------------------------------------------
+   * Instance members
+   * -------------------------------------------------------------------- */
+  /** Raw byte representation of the UUID. */
+  bytes;
+  // Cached string and hex representations to avoid recomputation.
+  _str;
+  _hex;
+  /**
+   * Constructs a new {@link UUID} instance from any supported input type.
+   * @param input - The value to parse (string or ArrayBufferView).
+   */
+  constructor(input) {
+    this.bytes = _UUID.parse(input);
+  }
+  /** Instance wrapper for {@link equals}. */
+  equals(...inputs) {
+    return _UUID.equals(this, ...inputs);
+  }
+  /** Instance wrapper for {@link compare}. */
+  compare(other) {
+    return _UUID.compare(this, other);
+  }
+  version() {
+    return _UUID.version(this);
+  }
+  /**
+   * Returns the RFC 4122 string representation of this UUID.
+   * @returns The formatted UUID string.
+   */
+  toString() {
+    if (this._str != null) {
+      return this._str;
+    }
+    const hex = this.toHex();
+    this._str = _UUID.formatHex(hex);
+    return this._str;
+  }
+  /**
+   * Returns the plain hexadecimal representation of this UUID.
+   * @returns A 32‑character hex string.
+   */
+  toHex() {
+    if (this._hex != null) {
+      return this._hex;
+    }
+    this._hex = Uint8ArrayUtils2.toHex(this.bytes);
+    return this._hex;
+  }
+  /**
+   * Returns a copy of the raw byte array.
+   * @returns A new Uint8Array containing the UUID bytes.
+   */
+  toBytes() {
+    return new Uint8Array(this.bytes);
+  }
+  /** JSON serialization helper – returns the RFC 4122 string. */
+  toJSON() {
+    return this.toString();
+  }
+};
+var UUID22 = class extends UUID2 {
+  toBuffer() {
+    return Buffer.from(this.bytes);
+  }
+};
+
 // src/nodejs/utils/sequelize-utils/SequelizeUtils.ts
-import { UUID as UUID2 } from "@powfix/uuid/node";
 var SequelizeUtils = class _SequelizeUtils {
   static decimal2Number(value) {
     if (value === null || value === void 0) {
@@ -76098,7 +76413,7 @@ var SequelizeUtils = class _SequelizeUtils {
       allowNull: false,
       primaryKey: true,
       unique: true,
-      defaultValue: () => UUID2.from(UuidUtils.v4()).toBuffer()
+      defaultValue: () => UUID22.from(UuidUtils.v4()).toBuffer()
     })
   });
   static buildUuidColumn(options) {
@@ -76108,10 +76423,10 @@ var SequelizeUtils = class _SequelizeUtils {
         type: "binary(16)",
         get() {
           const value = this.getDataValue(columnName);
-          return value != null ? UUID2.from(value) : value;
+          return value != null ? UUID22.from(value) : value;
         },
         set(input) {
-          const value = input != null ? UUID2.from(input).toBuffer() : input;
+          const value = input != null ? UUID22.from(input).toBuffer() : input;
           this.setDataValue(columnName, value);
         },
         ...overrideOptions
@@ -76121,10 +76436,10 @@ var SequelizeUtils = class _SequelizeUtils {
         type: "binary(16)",
         get() {
           const value = this.getDataValue(columnName);
-          return UUID2.from(value);
+          return UUID22.from(value);
         },
         set(input) {
-          const value = UUID2.from(input).toBuffer();
+          const value = UUID22.from(input).toBuffer();
           this.setDataValue(columnName, value);
         },
         ...overrideOptions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powfix/core-js",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "core package",
   "author": "Kwon Kyung-Min <powfix@gmail.com>",
   "private": false,
@@ -53,13 +53,13 @@
     "dist"
   ],
   "dependencies": {
-    "@powfix/uuid": "^0.1.2",
     "base-64": "^1.0.0",
     "eventemitter3": "^5.0.1",
     "jwt-decode": "^4.0.0",
     "uuid": "9.0.1"
   },
   "devDependencies": {
+    "@powfix/uuid": "^0.1.2",
     "@types/base-64": "1.0.2",
     "@types/node": "^24.5.1",
     "@types/uuid": "9.0.7",