javonet-ruby-sdk 2.5.15 → 2.5.17

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/protocol/CommandDeserializer.cjs

@@ -0,0 +1,188 @@
+"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 CommandDeserializer_exports = {};
+__export(CommandDeserializer_exports, {
+  CommandDeserializer: () => CommandDeserializer
+});
+module.exports = __toCommonJS(CommandDeserializer_exports);
+var import_Command = require("../../utils/Command.cjs");
+var import_CommandType = require("../../utils/CommandType.cjs");
+var import_Type = require("../../utils/Type.cjs");
+var import_TypeDeserializer = require("./TypeDeserializer.cjs");
+class CommandDeserializer {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.command = new import_Command.Command(buffer[0], buffer[10], []);
+    this.position = 11;
+  }
+  /**
+   * @returns {Command}
+   */
+  deserialize() {
+    while (!this.isAtEnd()) {
+      this.command = this.command.addArgToPayload(this.readObject(this.buffer[this.position]));
+    }
+    return this.command;
+  }
+  isAtEnd() {
+    return this.position === this.buffer.length;
+  }
+  readObject(typeNum) {
+    const type = Object.entries(import_Type.Type).find((entry) => entry[1] === typeNum)[0];
+    switch (type) {
+      case "JAVONET_COMMAND":
+        return this.readCommand();
+      case "JAVONET_STRING":
+        return this.readString();
+      case "JAVONET_INTEGER":
+        return this.readInt();
+      case "JAVONET_BOOLEAN":
+        return this.readBool();
+      case "JAVONET_FLOAT":
+        return this.readFloat();
+      case "JAVONET_BYTE":
+        return this.readByte();
+      case "JAVONET_CHAR":
+        return this.readChar();
+      case "JAVONET_LONG_LONG":
+        return this.readLongLong();
+      case "JAVONET_DOUBLE":
+        return this.readDouble();
+      case "JAVONET_UNSIGNED_LONG_LONG":
+        return this.readUllong;
+      case "JAVONET_UNSIGNED_INTEGER":
+        return this.readUInt();
+      case "JAVONET_NULL":
+        return this.readNull();
+      default:
+        throw "Unknown type - not supported in JavaScript";
+    }
+  }
+  readCommand() {
+    const p = this.position;
+    const numberOfElementsInPayload = import_TypeDeserializer.TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5));
+    const runtime = this.buffer[p + 5];
+    const commandType = this.buffer[p + 6];
+    this.position += 7;
+    const payload = new Array(numberOfElementsInPayload);
+    for (let i = 0; i < numberOfElementsInPayload; i++) {
+      payload[i] = this.readObject(this.buffer[this.position]);
+    }
+    return new import_Command.Command(runtime, commandType, payload);
+  }
+  // old implementation
+  // readCommand() {
+  //     const p = this.position
+  //     const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
+  //     const runtime = this.buffer[p + 5]
+  //     const type = this.buffer[p + 6]
+  //     this.position += 7
+  //     const command = new Command(runtime, type, [])
+  //     return this.readCommandRecursively(numberOfElementsInPayload, command)
+  // }
+  //
+  // readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
+  //     if (numberOfElementsInPayloadLeft === 0) return cmd
+  //     const p = this.position
+  //     cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
+  //     return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
+  // }
+  readString() {
+    let p = this.position;
+    const stringEncodingMode = this.buffer[p + 1];
+    const size = import_TypeDeserializer.TypeDeserializer.deserializeInt(this.buffer.slice(p + 2, p + 6));
+    this.position += 6;
+    p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeString(stringEncodingMode, this.buffer.slice(p, p + size));
+  }
+  readInt() {
+    const size = 4;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size));
+  }
+  readBool() {
+    const size = 1;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size));
+  }
+  readFloat() {
+    const size = 4;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size));
+  }
+  readByte() {
+    const size = 1;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size));
+  }
+  readChar() {
+    const size = 1;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size));
+  }
+  readLongLong() {
+    const size = 8;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size));
+  }
+  readDouble() {
+    const size = 8;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size));
+  }
+  readUllong() {
+    const size = 8;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size));
+  }
+  readUInt() {
+    const size = 4;
+    this.position += 2;
+    const p = this.position;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size));
+  }
+  readNull() {
+    const size = 1;
+    this.position += 2;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeNull();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandDeserializer
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/protocol/CommandSerializer.cjs

@@ -0,0 +1,64 @@
+"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 CommandSerializer_exports = {};
+__export(CommandSerializer_exports, {
+  CommandSerializer: () => CommandSerializer
+});
+module.exports = __toCommonJS(CommandSerializer_exports);
+var import_TypeSerializer = require("./TypeSerializer.cjs");
+var import_Command = require("../../utils/Command.cjs");
+var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+class CommandSerializer {
+  serialize(rootCommand, connectionData) {
+    const buffers = [];
+    buffers.push(Uint8Array.of(rootCommand.runtimeName, 0));
+    if (connectionData) {
+      buffers.push(connectionData.serializeConnectionData());
+    } else {
+      buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
+    }
+    buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Nodejs, rootCommand.commandType));
+    this.serializeRecursively(rootCommand, buffers);
+    return concatenateUint8Arrays(buffers);
+  }
+  serializeRecursively(command, buffers) {
+    for (const item of command.payload) {
+      if (item instanceof import_Command.Command) {
+        buffers.push(import_TypeSerializer.TypeSerializer.serializeCommand(item));
+        this.serializeRecursively(item, buffers);
+      } else {
+        buffers.push(import_TypeSerializer.TypeSerializer.serializePrimitive(item));
+      }
+    }
+  }
+}
+function concatenateUint8Arrays(arrays) {
+  let totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandSerializer
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/protocol/TypeDeserializer.cjs

@@ -0,0 +1,91 @@
+"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 TypeDeserializer_exports = {};
+__export(TypeDeserializer_exports, {
+  TypeDeserializer: () => TypeDeserializer
+});
+module.exports = __toCommonJS(TypeDeserializer_exports);
+var import_Command = require("../../utils/Command.cjs");
+var import_buffer = require("buffer");
+var import_StringEncodingMode = require("../../utils/StringEncodingMode.cjs");
+class TypeDeserializer {
+  static deserializeCommand(encodedCommand) {
+    return new import_Command.Command(encodedCommand[0], encodedCommand[1], []);
+  }
+  static deserializeString(stringEncodingMode, encodedString) {
+    switch (stringEncodingMode) {
+      case import_StringEncodingMode.StringEncodingMode.ASCII:
+        return String.fromCharCode(...encodedString);
+      case import_StringEncodingMode.StringEncodingMode.UTF8: {
+        const decoder = new TextDecoder("UTF-8");
+        return decoder.decode(new Uint8Array(encodedString));
+      }
+      case import_StringEncodingMode.StringEncodingMode.UTF16: {
+        let str = "";
+        let newBuffer = new Uint8Array(encodedString);
+        for (let i = 0; i < newBuffer.length; i++) {
+          newBuffer[i] = encodedString[i];
+        }
+        for (let i = 0; i < encodedString.length; i = i + 2) {
+          str += String.fromCharCode(newBuffer[i] + 256 * newBuffer[i + 1]);
+        }
+        return str;
+      }
+      case import_StringEncodingMode.StringEncodingMode.UTF32:
+        throw "Type utf32-encoded string not supported in JavaScript";
+      default:
+        throw "Unknown string encoding - not supported in JavaScript";
+    }
+  }
+  static deserializeInt(encodedInt) {
+    return encodedInt[0] & 255 | (encodedInt[1] & 255) << 8 | (encodedInt[2] & 255) << 16 | (encodedInt[3] & 255) << 24;
+  }
+  static deserializeBool(encodedBool) {
+    return encodedBool[0] === 1;
+  }
+  static deserializeFloat(encodedFloat) {
+    return import_buffer.Buffer.from(encodedFloat).readFloatLE();
+  }
+  static deserializeByte(encodedByte) {
+    return import_buffer.Buffer.from(encodedByte).readUint8();
+  }
+  static deserializeChar(encodedChar) {
+    return import_buffer.Buffer.from(encodedChar).readUint8();
+  }
+  static deserializeLongLong(encodedLongLong) {
+    return import_buffer.Buffer.from(encodedLongLong).readBigInt64LE();
+  }
+  static deserializeDouble(encodedDouble) {
+    return import_buffer.Buffer.from(encodedDouble).readDoubleLE();
+  }
+  static deserializeULLong(encodedULLong) {
+    return import_buffer.Buffer.from(encodedULLong).readBigUInt64LE();
+  }
+  static deserializeUInt(encodedUInt) {
+    return import_buffer.Buffer.from(encodedUInt).readUIntLE(0, 4);
+  }
+  // eslint-disable-next-line no-unused-vars
+  static deserializeNull(encodedNull = null) {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeDeserializer
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/protocol/TypeSerializer.cjs

@@ -0,0 +1,153 @@
+"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 TypeSerializer_exports = {};
+__export(TypeSerializer_exports, {
+  TypeSerializer: () => TypeSerializer
+});
+module.exports = __toCommonJS(TypeSerializer_exports);
+var import_Command = require("../../utils/Command.cjs");
+var import_Type = require("../../utils/Type.cjs");
+var import_StringEncodingMode = require("../../utils/StringEncodingMode.cjs");
+var import_buffer = require("buffer");
+var import_CustomError = require("../../utils/CustomError.cjs");
+const encoder = new TextEncoder();
+class TypeSerializer {
+  static serializePrimitive(payload_item) {
+    if (payload_item === null) {
+      return TypeSerializer.serializeNull();
+    }
+    if (payload_item instanceof import_Command.Command) {
+      return TypeSerializer.serializeCommand(payload_item);
+    } else if (typeof payload_item === "number" || payload_item instanceof Number) {
+      if (Number.isInteger(payload_item)) {
+        return TypeSerializer.serializeInt(payload_item);
+      } else {
+        return TypeSerializer.serializeDouble(payload_item);
+      }
+    } else if (typeof payload_item === "string" || payload_item instanceof String) {
+      return TypeSerializer.serializeString(payload_item);
+    } else if (typeof payload_item === "boolean" || payload_item instanceof Boolean) {
+      return TypeSerializer.serializeBool(payload_item);
+    } else {
+      if (payload_item instanceof Promise) {
+        throw new import_CustomError.CustomError("Type not supported - Promise", JSON.stringify(payload_item));
+      }
+      if (payload_item === void 0) {
+        throw "Type not supported - undefined";
+      }
+      throw "Unknown type - not supported in JavaScript";
+    }
+  }
+  static serializeCommand(command) {
+    const buffer = import_buffer.Buffer.alloc(7);
+    buffer.writeUInt8(import_Type.Type.JAVONET_COMMAND, 0);
+    buffer.fill(import_buffer.Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5);
+    buffer.writeUInt8(command.runtime, 5);
+    buffer.writeUInt8(command.commandType, 6);
+    return buffer;
+  }
+  static serializeString(string_value) {
+    let bytes = encoder.encode(string_value);
+    const buffer = import_buffer.Buffer.alloc(6 + bytes.length);
+    buffer.writeUInt8(import_Type.Type.JAVONET_STRING, 0);
+    buffer.writeUInt8(import_StringEncodingMode.StringEncodingMode.UTF8, 1);
+    buffer.fill(import_buffer.Buffer.from(this.serializeIntValue(bytes.length)), 2, 6);
+    buffer.fill(import_buffer.Buffer.from(bytes), 6, 6 + bytes.length);
+    return buffer;
+  }
+  static serializeInt(int_value) {
+    const buffer = import_buffer.Buffer.alloc(6);
+    buffer.writeUInt8(import_Type.Type.JAVONET_INTEGER, 0);
+    buffer.writeUInt8(4, 1);
+    buffer.writeInt32LE(int_value, 2);
+    return buffer;
+  }
+  static serializeBool(bool_value) {
+    const buffer = import_buffer.Buffer.alloc(3);
+    buffer.writeUInt8(import_Type.Type.JAVONET_BOOLEAN, 0);
+    buffer.writeUInt8(1, 1);
+    buffer.writeUInt8(bool_value ? 1 : 0, 2);
+    return buffer;
+  }
+  static serializeFloat(float_value) {
+    const buffer = import_buffer.Buffer.alloc(6);
+    buffer.writeUInt8(import_Type.Type.JAVONET_FLOAT, 0);
+    buffer.writeUInt8(4, 1);
+    buffer.writeFloatLE(float_value, 2);
+    return buffer;
+  }
+  static serializeByte(byte_value) {
+    const buffer = import_buffer.Buffer.alloc(3);
+    buffer.writeUInt8(import_Type.Type.JAVONET_BYTE, 0);
+    buffer.writeUInt8(1, 1);
+    buffer.writeUInt8(byte_value, 2);
+    return buffer;
+  }
+  static serializeChar(char_value) {
+    const buffer = import_buffer.Buffer.alloc(3);
+    buffer.writeUInt8(import_Type.Type.JAVONET_CHAR, 0);
+    buffer.writeUInt8(1, 1);
+    buffer.writeUInt8(char_value, 2);
+    return buffer;
+  }
+  static serializeLongLong(longlong_value) {
+    const buffer = import_buffer.Buffer.alloc(10);
+    buffer.writeUInt8(import_Type.Type.JAVONET_LONG_LONG, 0);
+    buffer.writeUInt8(8, 1);
+    buffer.writeBigInt64LE(BigInt(longlong_value), 2);
+    return buffer;
+  }
+  static serializeDouble(double_value) {
+    const buffer = import_buffer.Buffer.alloc(10);
+    buffer.writeUInt8(import_Type.Type.JAVONET_DOUBLE, 0);
+    buffer.writeUInt8(8, 1);
+    buffer.writeDoubleLE(double_value, 2);
+    return buffer;
+  }
+  static serializeULLong(ullong_value) {
+    const buffer = import_buffer.Buffer.alloc(10);
+    buffer.writeUInt8(import_Type.Type.JAVONET_UNSIGNED_LONG_LONG, 0);
+    buffer.writeUInt8(8, 1);
+    buffer.writeBigUInt64LE(ullong_value, 2);
+    return buffer;
+  }
+  static serializeUInt(uint_value) {
+    const buffer = import_buffer.Buffer.alloc(6);
+    buffer.writeUInt8(import_Type.Type.JAVONET_UNSIGNED_INTEGER, 0);
+    buffer.writeUInt8(4, 1);
+    buffer.writeUInt32LE(uint_value, 2);
+    return buffer;
+  }
+  static serializeNull() {
+    const buffer = import_buffer.Buffer.alloc(3);
+    buffer.writeUInt8(import_Type.Type.JAVONET_NULL, 0);
+    buffer.writeUInt8(1, 1);
+    buffer.writeUInt8(0, 2);
+    return buffer;
+  }
+  static serializeIntValue(int_value) {
+    const buffer = import_buffer.Buffer.alloc(4);
+    buffer.writeInt32LE(int_value, 0);
+    return buffer;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeSerializer
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/Receiver.cjs

@@ -0,0 +1,63 @@
+"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 Receiver_exports = {};
+__export(Receiver_exports, {
+  Receiver: () => Receiver
+});
+module.exports = __toCommonJS(Receiver_exports);
+var import_Interpreter = require("../interpreter/Interpreter.cjs");
+var import_CommandSerializer = require("../protocol/CommandSerializer.cjs");
+var import_Runtime = require("../../utils/Runtime.cjs");
+var import_InMemoryConnectionData = require("../../utils/connectionData/InMemoryConnectionData.cjs");
+const import_meta = {};
+let _RuntimeLogger = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+class Receiver {
+  static connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
+  Receiver() {
+    if (!_RuntimeLogger) {
+      const { RuntimeLogger } = require("../../utils/RuntimeLogger.cjs");
+      _RuntimeLogger = RuntimeLogger;
+    }
+    _RuntimeLogger?.printRuntimeInfo();
+  }
+  /**
+   * @param {number[]} messageByteArray
+   */
+  static sendCommand(messageByteArray) {
+    return new import_CommandSerializer.CommandSerializer().serialize(
+      new import_Interpreter.Interpreter().process(messageByteArray),
+      this.connectionData
+    );
+  }
+  /**
+   * @param {Int8Array} messageByteArray
+   * @returns {Int8Array}
+   */
+  static heartBeat(messageByteArray) {
+    let response = new Int8Array(2);
+    response[0] = messageByteArray[11];
+    response[1] = messageByteArray[12] - 2;
+    return response;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Receiver
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/ReceiverNative.cjs

@@ -0,0 +1,37 @@
+"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 ReceiverNative_exports = {};
+__export(ReceiverNative_exports, {
+  ReceiverNative: () => ReceiverNative
+});
+module.exports = __toCommonJS(ReceiverNative_exports);
+var import_Receiver = require("./Receiver.cjs");
+class ReceiverNative {
+  static sendCommand(messageByteArray) {
+    return import_Receiver.Receiver.sendCommand(messageByteArray);
+  }
+  static heartBeat(messageByteArray) {
+    return import_Receiver.Receiver.heartBeat(messageByteArray);
+  }
+}
+global.ReceiverNative = ReceiverNative;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReceiverNative
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/referenceCache/ReferencesCache.cjs

@@ -0,0 +1,65 @@
+"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 ReferencesCache_exports = {};
+__export(ReferencesCache_exports, {
+  ReferencesCache: () => ReferencesCache
+});
+module.exports = __toCommonJS(ReferencesCache_exports);
+var import_v4 = require("../../utils/nodejs/uuid/v4.cjs");
+let _cache = {};
+let _instance = null;
+class ReferencesCache {
+  /**
+   * @returns {ReferencesCache}
+   */
+  static getInstance() {
+    if (_instance === null) {
+      _instance = new ReferencesCache();
+    }
+    return _instance;
+  }
+  /**
+   * @param {any} reference
+   * @returns {string}
+   */
+  cacheReference(reference) {
+    let id = (0, import_v4.v4)();
+    _cache[id] = reference;
+    return id;
+  }
+  /**
+   * @param {string} id
+   * @returns {any}
+   */
+  resolveReference(id) {
+    return _cache[id];
+  }
+  /**
+   * @param {string} id
+   * @returns {number}
+   */
+  deleteReference(id) {
+    delete _cache[id];
+    return 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReferencesCache
+});