javonet-ruby-sdk 2.5.15 → 2.5.16

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

@@ -0,0 +1,103 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Runtime_exports = {};
+__export(Runtime_exports, {
+  getDependency: () => getDependency,
+  getDirname: () => getDirname,
+  getRequire: () => getRequire,
+  getRuntimeExtension: () => getRuntimeExtension,
+  isBrowserRuntime: () => isBrowserRuntime,
+  isEsmRuntime: () => isEsmRuntime,
+  isNodejsRuntime: () => isNodejsRuntime
+});
+module.exports = __toCommonJS(Runtime_exports);
+var import_module = require("module");
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+const import_meta = {};
+function isNodejsRuntime() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function isBrowserRuntime() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function isEsmRuntime() {
+  return typeof __filename === "undefined";
+}
+function getRuntimeExtension() {
+  return isEsmRuntime() ? "js" : "cjs";
+}
+const getRequire = (callerPath) => {
+  try {
+    if (isNodejsRuntime()) {
+      if (typeof require !== "undefined") {
+        return require;
+      }
+      if (callerPath === void 0) {
+        return (0, import_module.createRequire)(import_meta.url);
+      }
+      const baseUrl = callerPath?.startsWith("file:") ? callerPath : (0, import_url.pathToFileURL)(callerPath).href;
+      return (0, import_module.createRequire)(baseUrl);
+    }
+    return new Error("Runtime not supported");
+  } catch (error) {
+    throw error;
+  }
+};
+const getDirname = () => {
+  if (isEsmRuntime()) {
+    const __filename2 = (0, import_url.fileURLToPath)(import_meta.url);
+    return import_path.default.dirname(__filename2);
+  }
+  return __dirname;
+};
+const getDependency = (dependencyName, callerPathOrUrl) => {
+  try {
+    let baseUrl = callerPathOrUrl;
+    if (!baseUrl && typeof __filename !== "undefined") {
+      baseUrl = __filename;
+    }
+    const contextualRequire = getRequire(baseUrl);
+    return contextualRequire.resolve(dependencyName);
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve dependency '${dependencyName}' from '${callerPathOrUrl}': ${error.message}`
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDependency,
+  getDirname,
+  getRequire,
+  getRuntimeExtension,
+  isBrowserRuntime,
+  isEsmRuntime,
+  isNodejsRuntime
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/RuntimeLogger.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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var RuntimeLogger_exports = {};
+__export(RuntimeLogger_exports, {
+  RuntimeLogger: () => RuntimeLogger
+});
+module.exports = __toCommonJS(RuntimeLogger_exports);
+const import_meta = {};
+var import_Runtime = require("./Runtime.cjs");
+let os = null;
+let process = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+if ((0, import_Runtime.isNodejsRuntime)()) {
+  try {
+    os = requireDynamic("os");
+    process = requireDynamic("process");
+  } catch (error) {
+    throw error;
+  }
+}
+class RuntimeLogger {
+  static getRuntimeInfo() {
+    try {
+      return `JavaScript Managed Runtime Info:
+Node.js Version: ${process?.version}
+OS Version: ${os?.type()} ${os?.release()}
+Process Architecture: ${os?.arch()}
+Current Directory: ${process?.cwd()}
+`;
+    } catch (e) {
+      return "JavaScript Managed Runtime Info: Error while fetching runtime info";
+    }
+  }
+  static printRuntimeInfo() {
+    if (this.notLoggedYet) {
+      console.log(this.getRuntimeInfo());
+      this.notLoggedYet = false;
+    }
+  }
+}
+__publicField(RuntimeLogger, "notLoggedYet", true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeLogger
+});

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

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var RuntimeLoggerBrowser_exports = {};
+__export(RuntimeLoggerBrowser_exports, {
+  RuntimeLoggerBrowser: () => RuntimeLoggerBrowser
+});
+module.exports = __toCommonJS(RuntimeLoggerBrowser_exports);
+class RuntimeLoggerBrowser {
+  /**
+   * Gets runtime information in a browser environment.
+   * @method
+   * @returns {string}
+   */
+  static getRuntimeInfo() {
+    try {
+      return `JavaScript Managed Runtime Info:
+User-Agent: ${navigator.userAgent}
+Language: ${navigator.language}
+`;
+    } catch (error) {
+      return "JavaScript Managed Runtime Info: Error while fetching runtime info";
+    }
+  }
+  /**
+   * Prints runtime information to the console.
+   * @method
+   * @returns {void}
+   */
+  static printRuntimeInfo() {
+    if (this.notLoggedYet) {
+      console.log(this.getRuntimeInfo());
+      this.notLoggedYet = false;
+    }
+  }
+}
+__publicField(RuntimeLoggerBrowser, "notLoggedYet", true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeLoggerBrowser
+});

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

@@ -0,0 +1,43 @@
+"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 RuntimeName_exports = {};
+__export(RuntimeName_exports, {
+  RuntimeName: () => RuntimeName
+});
+module.exports = __toCommonJS(RuntimeName_exports);
+const RuntimeName = (
+  /** @type {const} */
+  {
+    Clr: 0,
+    Go: 1,
+    Jvm: 2,
+    Netcore: 3,
+    Perl: 4,
+    Python: 5,
+    Ruby: 6,
+    Nodejs: 7,
+    Cpp: 8,
+    Php: 9,
+    Python27: 10
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeName
+});

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

@@ -0,0 +1,62 @@
+"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 RuntimeNameHandler_exports = {};
+__export(RuntimeNameHandler_exports, {
+  RuntimeNameHandler: () => RuntimeNameHandler
+});
+module.exports = __toCommonJS(RuntimeNameHandler_exports);
+var import_RuntimeName = require("./RuntimeName.cjs");
+class RuntimeNameHandler {
+  /**
+   * @param {number} runtimeName
+   * @returns {string}
+   */
+  static getName(runtimeName) {
+    switch (runtimeName) {
+      case import_RuntimeName.RuntimeName.Clr:
+        return "clr";
+      case import_RuntimeName.RuntimeName.Go:
+        return "go";
+      case import_RuntimeName.RuntimeName.Jvm:
+        return "jvm";
+      case import_RuntimeName.RuntimeName.Netcore:
+        return "netcore";
+      case import_RuntimeName.RuntimeName.Perl:
+        return "perl";
+      case import_RuntimeName.RuntimeName.Python:
+        return "python";
+      case import_RuntimeName.RuntimeName.Ruby:
+        return "ruby";
+      case import_RuntimeName.RuntimeName.Nodejs:
+        return "nodejs";
+      case import_RuntimeName.RuntimeName.Cpp:
+        return "cpp";
+      case import_RuntimeName.RuntimeName.Php:
+        return "php";
+      case import_RuntimeName.RuntimeName.Python27:
+        return "python27";
+      default:
+        throw new Error("Invalid runtime name.");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeNameHandler
+});

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

@@ -0,0 +1,36 @@
+"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 StringEncodingMode_exports = {};
+__export(StringEncodingMode_exports, {
+  StringEncodingMode: () => StringEncodingMode
+});
+module.exports = __toCommonJS(StringEncodingMode_exports);
+const StringEncodingMode = (
+  /** @type {const} */
+  {
+    ASCII: 0,
+    UTF8: 1,
+    UTF16: 2,
+    UTF32: 3
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StringEncodingMode
+});

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

@@ -0,0 +1,44 @@
+"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 Type_exports = {};
+__export(Type_exports, {
+  Type: () => Type
+});
+module.exports = __toCommonJS(Type_exports);
+const Type = (
+  /** @type {const} */
+  {
+    JAVONET_COMMAND: 0,
+    JAVONET_STRING: 1,
+    JAVONET_INTEGER: 2,
+    JAVONET_BOOLEAN: 3,
+    JAVONET_FLOAT: 4,
+    JAVONET_BYTE: 5,
+    JAVONET_CHAR: 6,
+    JAVONET_LONG_LONG: 7,
+    JAVONET_DOUBLE: 8,
+    JAVONET_UNSIGNED_LONG_LONG: 9,
+    JAVONET_UNSIGNED_INTEGER: 10,
+    JAVONET_NULL: 11
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Type
+});

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
+});