javonet-ruby-sdk 2.5.15 → 2.5.17

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/connectionData/IConnectionData.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var IConnectionData_exports = {};
+__export(IConnectionData_exports, {
+  IConnectionData: () => IConnectionData
+});
+module.exports = __toCommonJS(IConnectionData_exports);
+class IConnectionData {
+  get connectionType() {
+    throw new Error("You have to implement the method connectionType!");
+  }
+  get hostname() {
+    throw new Error("You have to implement the method hostname!");
+  }
+  serializeConnectionData() {
+    throw new Error("You have to implement the method serializeConnectionData!");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IConnectionData
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/connectionData/InMemoryConnectionData.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InMemoryConnectionData_exports = {};
+__export(InMemoryConnectionData_exports, {
+  InMemoryConnectionData: () => InMemoryConnectionData
+});
+module.exports = __toCommonJS(InMemoryConnectionData_exports);
+var import_ConnectionType = require("../ConnectionType.cjs");
+var import_IConnectionData = require("./IConnectionData.cjs");
+class InMemoryConnectionData extends import_IConnectionData.IConnectionData {
+  constructor() {
+    super();
+    this._connectionType = import_ConnectionType.ConnectionType.IN_MEMORY;
+    this._hostname = "";
+  }
+  get connectionType() {
+    return this._connectionType;
+  }
+  get hostname() {
+    return this._hostname;
+  }
+  serializeConnectionData() {
+    return [this.connectionType, 0, 0, 0, 0, 0, 0];
+  }
+  /**
+   * @param {InMemoryConnectionData} other
+   * @returns {boolean}
+   */
+  equals(other) {
+    return other instanceof InMemoryConnectionData;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryConnectionData
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/connectionData/WsConnectionData.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WsConnectionData_exports = {};
+__export(WsConnectionData_exports, {
+  WsConnectionData: () => WsConnectionData
+});
+module.exports = __toCommonJS(WsConnectionData_exports);
+var import_ConnectionType = require("../ConnectionType.cjs");
+var import_IConnectionData = require("./IConnectionData.cjs");
+class WsConnectionData extends import_IConnectionData.IConnectionData {
+  /**
+   * @param {string} hostname - The hostname of the connection.
+   */
+  constructor(hostname) {
+    super();
+    this._hostname = hostname;
+    this._connectionType = import_ConnectionType.ConnectionType.WEB_SOCKET;
+  }
+  /** @type {ConnectionType} */
+  get connectionType() {
+    return this._connectionType;
+  }
+  /** @type {string} */
+  get hostname() {
+    return this._hostname;
+  }
+  /** @type {string} */
+  set hostname(value) {
+    this._hostname = value;
+  }
+  /**
+   * Serializes the connection data.
+   * @returns {number[]} An array of connection data values.
+   */
+  serializeConnectionData() {
+    return [this.connectionType, 0, 0, 0, 0, 0, 0];
+  }
+  equals(other) {
+    return other instanceof WsConnectionData && this._hostname === other.hostname;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WsConnectionData
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/exception/ExceptionSerializer.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ExceptionSerializer_exports = {};
+__export(ExceptionSerializer_exports, {
+  ExceptionSerializer: () => ExceptionSerializer
+});
+module.exports = __toCommonJS(ExceptionSerializer_exports);
+var import_CommandType = require("../CommandType.cjs");
+var import_Command = require("../Command.cjs");
+var import_RuntimeName = require("../RuntimeName.cjs");
+var import_ExceptionType = require("../ExceptionType.cjs");
+class ExceptionSerializer {
+  static serializeException(exception, command) {
+    let exceptionCommand = new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Exception, []);
+    exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception));
+    exceptionCommand = exceptionCommand.addArgToPayload(command.toString());
+    exceptionCommand = exceptionCommand.addArgToPayload(exception.name);
+    exceptionCommand = exceptionCommand.addArgToPayload(exception.message);
+    let stackClasses = [];
+    let stackMethods = [];
+    let stackLines = [];
+    let stackFiles = [];
+    this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles);
+    exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join("|"));
+    exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join("|"));
+    exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join("|"));
+    exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join("|"));
+    return exceptionCommand;
+  }
+  static getExceptionCode(exception) {
+    switch (exception.name) {
+      case "Error":
+        return import_ExceptionType.ExceptionType.EXCEPTION;
+      case "TypeError":
+        return import_ExceptionType.ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION;
+      case "RangeError":
+        return import_ExceptionType.ExceptionType.INDEX_OUT_OF_BOUNDS_EXCEPTION;
+      default:
+        return import_ExceptionType.ExceptionType.EXCEPTION;
+    }
+  }
+  static serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles) {
+    const stackTrace = exception.stack.split("\n").slice(1);
+    for (let i = 0; i < stackTrace.length; i++) {
+      const parts = stackTrace[i].trim().match(/at\s(.*)\s\((.*):(\d+):(\d+)\)/);
+      if (parts) {
+        stackClasses.push(parts[1]);
+        stackMethods.push("unknown");
+        stackLines.push(parts[3]);
+        stackFiles.push(parts[2]);
+      } else {
+        const parts2 = stackTrace[i].trim().match(/at\s(.*):(\d+):(\d+)/);
+        if (parts2) {
+          stackClasses.push("unknown");
+          stackMethods.push("unknown");
+          stackLines.push(parts2[2]);
+          stackFiles.push(parts2[1]);
+        }
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExceptionSerializer
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/exception/ExceptionThrower.cjs

@@ -0,0 +1,111 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ExceptionThrower_exports = {};
+__export(ExceptionThrower_exports, {
+  ExceptionThrower: () => ExceptionThrower
+});
+module.exports = __toCommonJS(ExceptionThrower_exports);
+var import_ExceptionType = require("../ExceptionType.cjs");
+class ExceptionThrower {
+  static throwException(commandException) {
+    let exceptionType = import_ExceptionType.ExceptionType.EXCEPTION;
+    let javonetStackCommand = "";
+    let exceptionName = "Node.js exception";
+    let exceptionMessage = "Node.js exception with empty message";
+    let stackTraceClasses = "";
+    let stackTraceMethods = "";
+    let stackTraceLines = "";
+    let stackTraceFiles = "";
+    switch (commandException.payload.length) {
+      case 8:
+        stackTraceFiles = commandException.payload[7];
+      case 7:
+        stackTraceLines = commandException.payload[6];
+      case 6:
+        stackTraceMethods = commandException.payload[5];
+      case 5:
+        stackTraceClasses = commandException.payload[4];
+      case 4:
+        exceptionMessage = commandException.payload[3];
+      case 3:
+        exceptionName = commandException.payload[2];
+      case 2:
+        javonetStackCommand = commandException.payload[1];
+      case 1:
+        exceptionType = commandException.payload[0];
+      default:
+        break;
+    }
+    let error;
+    switch (exceptionType) {
+      case import_ExceptionType.ExceptionType.EXCEPTION:
+      case import_ExceptionType.ExceptionType.IO_EXCEPTION:
+      case import_ExceptionType.ExceptionType.FILE_NOT_FOUND_EXCEPTION:
+      case import_ExceptionType.ExceptionType.RUNTIME_EXCEPTION:
+      case import_ExceptionType.ExceptionType.ARITHMETIC_EXCEPTION:
+        error = new Error();
+        break;
+      case import_ExceptionType.ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION:
+      case import_ExceptionType.ExceptionType.NULL_POINTER_EXCEPTION:
+        error = new TypeError();
+        break;
+      case import_ExceptionType.ExceptionType.INDEX_OUT_OF_BOUNDS_EXCEPTION:
+        error = new RangeError();
+        break;
+      default:
+        error = new Error();
+    }
+    error.stack = this.serializeStack(
+      stackTraceClasses,
+      stackTraceMethods,
+      stackTraceLines,
+      stackTraceFiles
+    );
+    error.name = exceptionName;
+    error.message = exceptionMessage;
+    return error;
+  }
+  static serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles) {
+    let stackTraceClassesArray = stackTraceClasses.split("|");
+    let stackTraceMethodsArray = stackTraceMethods.split("|");
+    let stackTraceLinesArray = stackTraceLines.split("|");
+    let stackTraceFilesArray = stackTraceFiles.split("|");
+    let stackTrace = "";
+    for (let i = 0; i < stackTraceClassesArray.length; i++) {
+      if (stackTraceClassesArray[i] != "") {
+        stackTrace += `    at ${stackTraceClassesArray[i]}`;
+      }
+      if (i < stackTraceMethodsArray.length && stackTraceMethodsArray[i] != "") {
+        stackTrace += `.${stackTraceMethodsArray[i]}`;
+      }
+      if (i < stackTraceFilesArray.length && stackTraceFilesArray[i] != "") {
+        stackTrace += ` ${stackTraceFilesArray[i]}`;
+      }
+      if (i < stackTraceLinesArray.length && stackTraceLinesArray[i] != "") {
+        stackTrace += `:${stackTraceLinesArray[i]}`;
+      }
+      stackTrace += "\n";
+    }
+    return stackTrace;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExceptionThrower
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/guid/generateGuid.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generateGuid_exports = {};
+__export(generateGuid_exports, {
+  generateGUID: () => generateGUID
+});
+module.exports = __toCommonJS(generateGuid_exports);
+function generateGUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateGUID
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/nodejs/TypesConverter.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TypesConverter_exports = {};
+__export(TypesConverter_exports, {
+  ConvertTypeHandler: () => ConvertTypeHandler,
+  JType: () => JType,
+  TypesConverter: () => TypesConverter
+});
+module.exports = __toCommonJS(TypesConverter_exports);
+class ConvertTypeHandler {
+  constructor() {
+    this.requiredParametersCount = 1;
+  }
+  /**
+   * Processes the given command to convert JType to Type.
+   * @param {Object} command - The command to process.
+   * @returns {any} The converted type.
+   */
+  process(command) {
+    this.validateCommand(command);
+    return TypesConverter.convertJTypeToType(command.payload[0]);
+  }
+  /**
+   * Validates the command to ensure it has enough parameters.
+   * @param {Object} command - The command to validate.
+   */
+  validateCommand(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error("ConvertTypeHandler parameters mismatch");
+    }
+  }
+}
+class TypesConverter {
+  /**
+   * Converts a JavaScript type to a JType equivalent.
+   * @param {Function} type - The JavaScript type.
+   * @returns {number} The corresponding JType.
+   */
+  static convertTypeToJType(type) {
+    switch (type) {
+      case Boolean:
+        return JType.Boolean;
+      case Number:
+        return JType.Float;
+      // Assuming Number maps to Float
+      case String:
+        return JType.String;
+      case Object:
+        return JType.Null;
+      // Assuming Object maps to Null
+      default:
+        return JType.Null;
+    }
+  }
+  /**
+   * Converts a JType to a JavaScript type equivalent.
+   * @param {number} type - The JType to convert.
+   * @returns {Function} The corresponding JavaScript type.
+   */
+  static convertJTypeToType(type) {
+    switch (type) {
+      case JType.Boolean:
+        return Boolean;
+      case JType.Float:
+        return Number;
+      case JType.String:
+        return String;
+      case JType.Null:
+        return null;
+      default:
+        return null;
+    }
+  }
+}
+const JType = {
+  Boolean: 1,
+  Float: 2,
+  String: 3,
+  Null: 4
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConvertTypeHandler,
+  JType,
+  TypesConverter
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/nodejs/connectionData/TcpConnectionData.cjs

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TcpConnectionData_exports = {};
+__export(TcpConnectionData_exports, {
+  TcpConnectionData: () => TcpConnectionData
+});
+module.exports = __toCommonJS(TcpConnectionData_exports);
+var import_IConnectionData = require("../../connectionData/IConnectionData.cjs");
+var import_ConnectionType = require("../../ConnectionType.cjs");
+var import_Runtime = require("../../Runtime.cjs");
+const import_meta = {};
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+class TcpConnectionData extends import_IConnectionData.IConnectionData {
+  constructor(hostname, port) {
+    super();
+    this._port = port;
+    this._hostname = hostname;
+    this._connectionType = import_ConnectionType.ConnectionType.TCP;
+    if (hostname === "localhost") {
+      this.ipAddress = "127.0.0.1";
+    } else {
+      this.ipAddress = this.resolveIpAddress(hostname);
+    }
+  }
+  get connectionType() {
+    return this._connectionType;
+  }
+  get hostname() {
+    return this._hostname;
+  }
+  /**
+   * @param {TcpConnectionData} other
+   * @returns {boolean}
+   */
+  equals(other) {
+    if (other instanceof TcpConnectionData) {
+      return this.ipAddress === other.ipAddress && this._port === other._port;
+    }
+    return false;
+  }
+  /**
+   * @param {string} hostname
+   * @returns {string|null}
+   */
+  resolveIpAddress(hostname) {
+    try {
+      if ((0, import_Runtime.isNodejsRuntime)()) {
+        const ipPattern = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/;
+        if (ipPattern.test(hostname)) {
+          return hostname;
+        } else {
+          const dns = requireDynamic("dns");
+          return dns.resolve4(hostname, (err, addresses) => {
+            if (err) {
+              console.error(err);
+              return null;
+            }
+            return addresses[0];
+          });
+        }
+      }
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("dns module not found. Please install it using npm install dns");
+      }
+      throw error;
+    }
+  }
+  serializeConnectionData() {
+    let result = [this.connectionType];
+    result = result.concat(this.#getAddressBytes());
+    result = result.concat(this.#getPortBytes());
+    return result;
+  }
+  #getAddressBytes() {
+    return this.ipAddress.split(".").map(Number);
+  }
+  #getPortBytes() {
+    return [this._port & 255, this._port >> 8];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TcpConnectionData
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/nodejs/uuid/REGEX.cjs

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var REGEX_exports = {};
+__export(REGEX_exports, {
+  regex: () => regex
+});
+module.exports = __toCommonJS(REGEX_exports);
+const regex = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  regex
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/nodejs/uuid/rng.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rng_exports = {};
+__export(rng_exports, {
+  rng: () => rng
+});
+module.exports = __toCommonJS(rng_exports);
+var import_Runtime = require("../../Runtime.cjs");
+const import_meta = {};
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+const rnds8Pool = new Uint8Array(256);
+let poolPtr = rnds8Pool.length;
+function rng() {
+  try {
+    const crypto = requireDynamic("crypto");
+    if (poolPtr > rnds8Pool.length - 16) {
+      crypto.randomFillSync(rnds8Pool);
+      poolPtr = 0;
+    }
+    return rnds8Pool.slice(poolPtr, poolPtr += 16);
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error("crypto module not found. Please install it using npm install crypto");
+    }
+    throw error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rng
+});