javonet-ruby-sdk 2.5.15 → 2.5.17

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/ArraySetItemHandler.cjs

@@ -0,0 +1,60 @@
+"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 ArraySetItemHandler_exports = {};
+__export(ArraySetItemHandler_exports, {
+  ArraySetItemHandler: () => ArraySetItemHandler
+});
+module.exports = __toCommonJS(ArraySetItemHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ArraySetItemHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 3;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Array Set Item parameters mismatch");
+      }
+      let array = command.payload[0];
+      let value = command.payload[2];
+      let indexes;
+      if (Array.isArray(command.payload[1])) {
+        indexes = command.payload[1];
+      } else {
+        indexes = [command.payload[1]];
+      }
+      if (indexes.length === 1) {
+        array[indexes] = value;
+      } else {
+        for (let i = 0; i < indexes.length - 1; i++) {
+          array = array[indexes[i]];
+        }
+        array[indexes[indexes.length - 1]] = value;
+      }
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArraySetItemHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/CastingHandler.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 CastingHandler_exports = {};
+__export(CastingHandler_exports, {
+  CastingHandler: () => CastingHandler
+});
+module.exports = __toCommonJS(CastingHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class CastingHandler extends import_AbstractHandler.AbstractHandler {
+  // eslint-disable-next-line no-unused-vars
+  process(command) {
+    throw new Error(`Dynamically typed languages are not supporting casting`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CastingHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/ConvertTypeHandler.cjs

@@ -0,0 +1,53 @@
+"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 ConvertTypeHandler_exports = {};
+__export(ConvertTypeHandler_exports, {
+  ConvertTypeHandler: () => ConvertTypeHandler
+});
+module.exports = __toCommonJS(ConvertTypeHandler_exports);
+var import_TypesConverter = require("../../utils/nodejs/TypesConverter.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ConvertTypeHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    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 import_TypesConverter.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");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConvertTypeHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/CreateClassInstanceHandler.cjs

@@ -0,0 +1,60 @@
+"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 CreateClassInstanceHandler_exports = {};
+__export(CreateClassInstanceHandler_exports, {
+  CreateClassInstanceHandler: () => CreateClassInstanceHandler
+});
+module.exports = __toCommonJS(CreateClassInstanceHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Create Class Instance parameters mismatch");
+      }
+      let clazz = command.payload[0];
+      let constructorArguments = command.payload.slice(1);
+      let instance = new clazz(...constructorArguments);
+      if (typeof instance === "undefined") {
+        let methods = Object.getOwnPropertyNames(type).filter(function(property) {
+          return typeof type[property] === "function";
+        });
+        let message = `Method 'constructor' not found in class. Available methods:
+`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}
+`;
+        });
+        throw new Error(message);
+      } else {
+        return instance;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateClassInstanceHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/DestructReferenceHandler.cjs

@@ -0,0 +1,42 @@
+"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 DestructReferenceHandler_exports = {};
+__export(DestructReferenceHandler_exports, {
+  DestructReferenceHandler: () => DestructReferenceHandler
+});
+module.exports = __toCommonJS(DestructReferenceHandler_exports);
+var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class DestructReferenceHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      let cache = import_ReferencesCache.ReferencesCache.getInstance();
+      return cache.deleteReference(command.payload[0]);
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DestructReferenceHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/EnableNamespaceHandler.cjs

@@ -0,0 +1,56 @@
+"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 EnableNamespaceHandler_exports = {};
+__export(EnableNamespaceHandler_exports, {
+  EnableNamespaceHandler: () => EnableNamespaceHandler
+});
+module.exports = __toCommonJS(EnableNamespaceHandler_exports);
+var import_NamespaceCache = require("../namespaceCache/NamespaceCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class EnableNamespaceHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.requiredParametersCount = 1;
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error(this.constructor.name + " parameters mismatch");
+      }
+      const namespace_cache = new import_NamespaceCache.NamespaceCache();
+      for (let payload of command.payload) {
+        if (typeof payload === "string") {
+          namespace_cache.cacheNamespace(payload);
+        }
+        if (Array.isArray(payload)) {
+          for (let namespace_to_enable of payload) {
+            namespace_cache.cacheNamespace(namespace_to_enable);
+          }
+        }
+      }
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnableNamespaceHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/EnableTypeHandler.cjs

@@ -0,0 +1,56 @@
+"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 EnableTypeHandler_exports = {};
+__export(EnableTypeHandler_exports, {
+  EnableTypeHandler: () => EnableTypeHandler
+});
+module.exports = __toCommonJS(EnableTypeHandler_exports);
+var import_TypeCache = require("../typeCache/TypeCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class EnableTypeHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Get Type parameters mismatch");
+      }
+      const typeCache = new import_TypeCache.TypeCache();
+      for (let payload of command.payload) {
+        if (typeof payload === "string") {
+          typeCache.cacheType(payload);
+        }
+        if (Array.isArray(payload)) {
+          for (let namespace_to_enable of payload) {
+            typeCache.cacheType(namespace_to_enable);
+          }
+        }
+      }
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnableTypeHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetGlobalStaticFieldHandler.cjs

@@ -0,0 +1,60 @@
+"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 GetGlobalStaticFieldHandler_exports = {};
+__export(GetGlobalStaticFieldHandler_exports, {
+  GetGlobalStaticFieldHandler: () => GetGlobalStaticFieldHandler
+});
+module.exports = __toCommonJS(GetGlobalStaticFieldHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetGlobalStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Get global static field parameters mismatch");
+      }
+      const { payload } = command;
+      const splitted = payload[0].split(".");
+      let fieldToGet;
+      for (let i = 0; i < splitted.length; i++) {
+        fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]];
+        if (typeof fieldToGet === "undefined") {
+          let fields = Object.keys(global);
+          let message = `Field ${payload[0]} not found in global. Available fields:
+`;
+          fields.forEach((fieldIter) => {
+            message += `${fieldIter}
+`;
+          });
+          throw new Error(message);
+        }
+      }
+      return fieldToGet;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetGlobalStaticFieldHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetInstanceFieldHandler.cjs

@@ -0,0 +1,59 @@
+"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 GetInstanceFieldHandler_exports = {};
+__export(GetInstanceFieldHandler_exports, {
+  GetInstanceFieldHandler: () => GetInstanceFieldHandler
+});
+module.exports = __toCommonJS(GetInstanceFieldHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetInstanceFieldHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 2;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Get Instance Field parameters mismatch");
+      }
+      const { payload } = command;
+      let instance = payload[0];
+      let field = payload[1];
+      let instanceField = instance[field];
+      if (typeof instanceField === "undefined") {
+        let fields = Object.keys(instance);
+        let message = `Field ${field} not found in object. Available fields:
+`;
+        fields.forEach((fieldIter) => {
+          message += `${fieldIter}
+`;
+        });
+        throw new Error(message);
+      } else {
+        return instanceField;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetInstanceFieldHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetInstanceMethodAsDelegateHandler.cjs

@@ -0,0 +1,83 @@
+"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 GetInstanceMethodAsDelegateHandler_exports = {};
+__export(GetInstanceMethodAsDelegateHandler_exports, {
+  GetInstanceMethodAsDelegateHandler: () => GetInstanceMethodAsDelegateHandler
+});
+module.exports = __toCommonJS(GetInstanceMethodAsDelegateHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetInstanceMethodAsDelegateHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.method = null;
+    this.requiredParametersCount = 2;
+    this.args = [];
+    this.instance = null;
+  }
+  /**
+   * Processes a command to retrieve an instance method as a delegate.
+   * @param {Object} command - The command containing payload data.
+   * @param {Array<*>} command.payload - The payload containing instance, method name, and arguments.
+   * @returns {Function} The delegate for the instance method.
+   * @throws {Error} If the parameters mismatch or the method cannot be found.
+   */
+  process(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error(`${this.constructor.name} parameters mismatch`);
+    }
+    this.instance = command.payload[0];
+    const methodName = command.payload[1];
+    this.args = command.payload.length > 2 ? command.payload.slice(2) : [];
+    this.method = this.getMethod(this.instance, methodName);
+    if (!this.method) {
+      throw this.createMethodNotFoundError(this.instance, methodName);
+    }
+    const methodDelegate = this.method.bind(this.instance);
+    return methodDelegate;
+  }
+  /**
+   * Retrieves the method from the type.
+   * @param {Object} type - The class or constructor to search for the method.
+   * @param {string} methodName - The name of the method.
+   * @returns {Function|null} The found method or null if not found.
+   */
+  getMethod(type, methodName) {
+    const method = type[methodName];
+    return typeof method === "function" ? method : null;
+  }
+  /**
+   * Creates an error message when the method is not found.
+   * @param {Object} type - The class or constructor.
+   * @param {string} methodName - The method name.
+   * @returns {Error} The error with detailed message.
+   */
+  createMethodNotFoundError(type, methodName) {
+    const methods = Object.getOwnPropertyNames(type.prototype).filter(
+      (key) => typeof type.prototype[key] === "function"
+    );
+    const availableMethods = methods.map((name) => `${name}()`);
+    const message = `Method ${methodName} not found in class ${type.name}. Available instance public methods:
+${availableMethods.join("\n")}`;
+    return new Error(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetInstanceMethodAsDelegateHandler
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/GetStaticFieldHandler.cjs

@@ -0,0 +1,59 @@
+"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 GetStaticFieldHandler_exports = {};
+__export(GetStaticFieldHandler_exports, {
+  GetStaticFieldHandler: () => GetStaticFieldHandler
+});
+module.exports = __toCommonJS(GetStaticFieldHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class GetStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 2;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Array Static Field parameters mismatch");
+      }
+      const { payload } = command;
+      let type = payload[0];
+      let field = payload[1];
+      let staticField = type[field];
+      if (typeof staticField === "undefined") {
+        let fields = Object.keys(type);
+        let message = `Field ${field} not found in class. Available fields:
+`;
+        fields.forEach((fieldIter) => {
+          message += `${fieldIter}
+`;
+        });
+        throw new Error(message);
+      } else {
+        return staticField;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GetStaticFieldHandler
+});