hana-kgvector 0.1.0

package/dist/lib-J24D2XQX.js

@@ -0,0 +1,1256 @@
+import {
+  require_Stream
+} from "./chunk-I3F3SOHM.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-VUNV25KB.js";
+
+// node_modules/.pnpm/ms@2.0.0/node_modules/ms/index.js
+var require_ms = __commonJS({
+  "node_modules/.pnpm/ms@2.0.0/node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isNaN(val) === false) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      if (ms >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (ms >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (ms >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (ms >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
+    }
+    function plural(ms, n, name) {
+      if (ms < n) {
+        return;
+      }
+      if (ms < n * 1.5) {
+        return Math.floor(ms / n) + " " + name;
+      }
+      return Math.ceil(ms / n) + " " + name + "s";
+    }
+  }
+});
+
+// node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/debug.js
+var require_debug = __commonJS({
+  "node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/debug.js"(exports, module) {
+    "use strict";
+    exports = module.exports = createDebug.debug = createDebug["default"] = createDebug;
+    exports.coerce = coerce;
+    exports.disable = disable;
+    exports.enable = enable;
+    exports.enabled = enabled;
+    exports.humanize = require_ms();
+    exports.instances = [];
+    exports.names = [];
+    exports.skips = [];
+    exports.formatters = {};
+    function selectColor(namespace) {
+      var hash = 0, i;
+      for (i in namespace) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return exports.colors[Math.abs(hash) % exports.colors.length];
+    }
+    function createDebug(namespace) {
+      var prevTime;
+      function debug() {
+        if (!debug.enabled) return;
+        var self = debug;
+        var curr = +/* @__PURE__ */ new Date();
+        var ms = curr - (prevTime || curr);
+        self.diff = ms;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        args[0] = exports.coerce(args[0]);
+        if ("string" !== typeof args[0]) {
+          args.unshift("%O");
+        }
+        var index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+          if (match === "%%") return match;
+          index++;
+          var formatter = exports.formatters[format];
+          if ("function" === typeof formatter) {
+            var val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        exports.formatArgs.call(self, args);
+        var logFn = debug.log || exports.log || console.log.bind(console);
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.enabled = exports.enabled(namespace);
+      debug.useColors = exports.useColors();
+      debug.color = selectColor(namespace);
+      debug.destroy = destroy;
+      if ("function" === typeof exports.init) {
+        exports.init(debug);
+      }
+      exports.instances.push(debug);
+      return debug;
+    }
+    function destroy() {
+      var index = exports.instances.indexOf(this);
+      if (index !== -1) {
+        exports.instances.splice(index, 1);
+        return true;
+      } else {
+        return false;
+      }
+    }
+    function enable(namespaces) {
+      exports.save(namespaces);
+      exports.names = [];
+      exports.skips = [];
+      var i;
+      var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+      var len = split.length;
+      for (i = 0; i < len; i++) {
+        if (!split[i]) continue;
+        namespaces = split[i].replace(/\*/g, ".*?");
+        if (namespaces[0] === "-") {
+          exports.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+        } else {
+          exports.names.push(new RegExp("^" + namespaces + "$"));
+        }
+      }
+      for (i = 0; i < exports.instances.length; i++) {
+        var instance = exports.instances[i];
+        instance.enabled = exports.enabled(instance.namespace);
+      }
+    }
+    function disable() {
+      exports.enable("");
+    }
+    function enabled(name) {
+      if (name[name.length - 1] === "*") {
+        return true;
+      }
+      var i, len;
+      for (i = 0, len = exports.skips.length; i < len; i++) {
+        if (exports.skips[i].test(name)) {
+          return false;
+        }
+      }
+      for (i = 0, len = exports.names.length; i < len; i++) {
+        if (exports.names[i].test(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error) return val.stack || val.message;
+      return val;
+    }
+  }
+});
+
+// node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports = module.exports = require_debug();
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = "undefined" != typeof chrome && "undefined" != typeof chrome.storage ? chrome.storage.local : localstorage();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && window.process.type === "renderer") {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    exports.formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (err) {
+        return "[UnexpectedJSONParseError]: " + err.message;
+      }
+    };
+    function formatArgs(args) {
+      var useColors2 = this.useColors;
+      args[0] = (useColors2 ? "%c" : "") + this.namespace + (useColors2 ? " %c" : " ") + args[0] + (useColors2 ? "%c " : " ") + "+" + exports.humanize(this.diff);
+      if (!useColors2) return;
+      var c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      var index = 0;
+      var lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, function(match) {
+        if ("%%" === match) return;
+        index++;
+        if ("%c" === match) {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    function log() {
+      return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
+    }
+    function save(namespaces) {
+      try {
+        if (null == namespaces) {
+          exports.storage.removeItem("debug");
+        } else {
+          exports.storage.debug = namespaces;
+        }
+      } catch (e) {
+      }
+    }
+    function load() {
+      var r;
+      try {
+        r = exports.storage.debug;
+      } catch (e) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    exports.enable(load());
+    function localstorage() {
+      try {
+        return window.localStorage;
+      } catch (e) {
+      }
+    }
+  }
+});
+
+// node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/node.js"(exports, module) {
+    "use strict";
+    var tty = __require("tty");
+    var util = __require("util");
+    exports = module.exports = require_debug();
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      supportsColor = __require("supports-color");
+      if (supportsColor && supportsColor.level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (err) {
+    }
+    var supportsColor;
+    exports.inspectOpts = Object.keys(process.env).filter(function(key) {
+      return /^debug_/i.test(key);
+    }).reduce(function(obj, key) {
+      var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
+        return k.toUpperCase();
+      });
+      var val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
+      else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
+      else if (val === "null") val = null;
+      else val = Number(val);
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    exports.formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map(function(str) {
+        return str.trim();
+      }).join(" ");
+    };
+    exports.formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+    function formatArgs(args) {
+      var name = this.namespace;
+      var useColors2 = this.useColors;
+      if (useColors2) {
+        var c = this.color;
+        var colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        var prefix = "  " + colorCode + ";1m" + name + " \x1B[0m";
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      } else {
+        return (/* @__PURE__ */ new Date()).toISOString() + " ";
+      }
+    }
+    function log() {
+      return process.stderr.write(util.format.apply(util, arguments) + "\n");
+    }
+    function save(namespaces) {
+      if (null == namespaces) {
+        delete process.env.DEBUG;
+      } else {
+        process.env.DEBUG = namespaces;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug) {
+      debug.inspectOpts = {};
+      var keys = Object.keys(exports.inspectOpts);
+      for (var i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    exports.enable(load());
+  }
+});
+
+// node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "node_modules/.pnpm/debug@3.1.0/node_modules/debug/src/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer") {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
+// node_modules/.pnpm/@sap+hana-client@2.27.19/node_modules/@sap/hana-client/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/.pnpm/@sap+hana-client@2.27.19/node_modules/@sap/hana-client/lib/index.js"(exports, module) {
+    var fs = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var net = __require("net");
+    var debug = require_src()("@sap/hana-client:index");
+    debug.log = console.info.bind(console);
+    var name = "index.js";
+    var majorVersion = process.versions.node.split(".")[0];
+    debug("Starting %s", name);
+    var extensions = {
+      "darwin": ".dylib",
+      "linux": ".so",
+      "win32": ".dll"
+    };
+    var db = null;
+    function isMusl() {
+      const output = __require("child_process").spawnSync("ldd", ["--version"]).stderr;
+      if (output && output.toString("utf8").indexOf("musl") > -1) {
+        return true;
+      }
+      return false;
+    }
+    var readPipe = null;
+    function refPipe() {
+      readPipe.ref();
+    }
+    function unrefPipe() {
+      readPipe.unref();
+    }
+    function setupPipe(pipeInfo2) {
+      if (!db) return;
+      var ldb = db;
+      if (process.platform === "win32") {
+        readPipe = net.createConnection(pipeInfo2["IPCEndpoint"]);
+      } else {
+        readPipe = net.Socket({
+          fd: pipeInfo2["fd"],
+          readable: true
+        });
+      }
+      readPipe.unref();
+      readPipe.on("data", function(data) {
+        ldb.__runCallbacks();
+      });
+      ldb.__setRefFunctions(refPipe, unrefPipe);
+    }
+    var InternalResultSetParser = class {
+      // initialize and read header
+      constructor(rs_bin) {
+        if (!Buffer.isBuffer(rs_bin)) {
+          this.throwError("rs_bin is not a Buffer in InternalResultSetParser constructor");
+        } else if (rs_bin.length < 16) {
+          this.throwError("rs_bin length of " + rs_bin.length + " is too small in InternalResultSetParser constructor");
+        }
+        this.m_buffer = rs_bin;
+        this.m_curr_offset = 0;
+        this.m_in_array_value = false;
+        var length_in_buffer = this.privateReadUInt64();
+        if (this.m_buffer.length != length_in_buffer) {
+          this.throwError("rs_bin length of " + this.m_buffer.length + " does not match internal length of " + length_in_buffer + " in InternalResultSetParser constructor");
+        }
+        this.numberOfRows = this.privateReadUInt32();
+        this.numberOfColumns = this.privateReadUInt32();
+        if (this.numberOfColumns < 1 || this.numberOfColumns > 65535) {
+          this.throwError("Invalid numberOfColumns of " + this.numberOfColumns + " in InternalResultSetParser constructor");
+        }
+        this.columnNames = [];
+        for (var i = 0; i < this.numberOfColumns; i++) {
+          var col_name = this.readValue();
+          if (typeof col_name !== "string") {
+            this.throwError("Invalid column name type of " + typeof col_name + " in InternalResultSetParser constructor");
+          }
+          this.columnNames.push(col_name);
+        }
+        this.columnTableNames = [];
+        for (var i = 0; i < this.numberOfColumns; i++) {
+          var col_table_name = this.readValue();
+          if (col_table_name !== null && typeof col_table_name !== "string") {
+            this.throwError("Invalid read column table name type of " + typeof col_table_name + " in InternalResultSetParser constructor");
+          }
+          this.columnTableNames.push(col_table_name);
+        }
+      }
+      throwError(msg) {
+        var err = new Error("Error making result set Object: " + msg);
+        err.code = -20009;
+        err.sqlState = "HY000";
+        throw err;
+      }
+      // read the next value
+      readValue() {
+        const I_RS_NULL = 1;
+        const I_RS_BOOLEAN = 2;
+        const I_RS_INT32 = 3;
+        const I_RS_DOUBLE = 4;
+        const I_RS_STRING = 5;
+        const I_RS_BINARY = 6;
+        const I_RS_ARRAY = 7;
+        if (this.m_curr_offset >= this.m_buffer_length) {
+          this.throwError("InternalResultSetParser.readValue already at end of buffer");
+        }
+        var type = this.m_buffer.readInt8(this.m_curr_offset++);
+        switch (type) {
+          case I_RS_NULL:
+            return null;
+          case I_RS_BOOLEAN:
+            var val = this.m_buffer.readInt8(this.m_curr_offset++);
+            return val ? true : false;
+          case I_RS_INT32:
+            var num = this.m_buffer.readInt32LE(this.m_curr_offset);
+            this.m_curr_offset += 4;
+            return num;
+          case I_RS_DOUBLE:
+            var num = this.m_buffer.readDoubleLE(this.m_curr_offset);
+            this.m_curr_offset += 8;
+            return num;
+          case I_RS_STRING:
+            var len = this.privateReadUInt32();
+            var str = this.m_buffer.toString("utf8", this.m_curr_offset, this.m_curr_offset + len);
+            this.m_curr_offset += len;
+            return str;
+          case I_RS_BINARY:
+            var len = this.privateReadUInt32();
+            var bin = this.m_buffer.subarray(this.m_curr_offset, this.m_curr_offset + len);
+            this.m_curr_offset += len;
+            return bin;
+          case I_RS_ARRAY:
+            var num_elements = this.m_buffer.readInt32LE(this.m_curr_offset);
+            this.m_curr_offset += 4;
+            if (this.m_in_array_value) {
+              this.throwError("InternalResultSetParser.readValue nested array value");
+            }
+            this.m_in_array_value = true;
+            var array = [];
+            for (var i = 0; i < num_elements; i++) {
+              array.push(this.readValue());
+            }
+            this.m_in_array_value = false;
+            return array;
+        }
+        ;
+        this.throwError("InternalResultSetParser.readValue unexpected value type code of " + type);
+      }
+      // confirm that all data in the binary buffer was read
+      verifyAtEnd() {
+        if (this.m_curr_offset != this.m_buffer.length) {
+          this.throwError("Verify at end failed.  m_curr_offset:" + this.m_curr_offset + " m_buffer.length:" + this.m_buffer.length);
+        }
+      }
+      // internal method used to implement InternalResultSetParser itself
+      privateReadUInt32() {
+        var val = this.m_buffer.readInt32LE(this.m_curr_offset);
+        this.m_curr_offset += 4;
+        return val;
+      }
+      privateReadUInt64() {
+        var val;
+        if (majorVersion >= 12) {
+          val = this.m_buffer.readBigUInt64LE(this.m_curr_offset);
+          this.m_curr_offset += 8;
+        } else {
+          var low_val = this.privateReadUInt32();
+          var high_val = this.privateReadUInt32();
+          val = low_val + high_val * 4294967296;
+        }
+        return val;
+      }
+      /* member data:
+       *   numberOfRows: number of rows in result set
+       *   numberOfColumns: number of columns in result set
+       *   columnNames: array of strings of column names
+       *   columnTableNames: array of (strings or NULL) of column table names
+       * member data that should be considered private:
+       *   m_buffer: the entire binary buffer we are parsing
+       *   m_curr_offset: current offset of m_buffer for next read
+       *   m_in_array_value: true when elements remain in I_RS_ARRAY
+       */
+    };
+    function translateFromInternalResultSet(options, rs_bin) {
+      var rowsAsArray = false;
+      var nestTables = false;
+      if (options !== null) {
+        if (options.rowsAsArray) {
+          rowsAsArray = true;
+        }
+        if (options.nestTables) {
+          nestTables = true;
+        }
+      }
+      var rs_parser = new InternalResultSetParser(rs_bin);
+      var column_names = rs_parser.columnNames;
+      var column_table_names = rs_parser.columnTableNames;
+      var rows = [];
+      var number_of_rows = rs_parser.numberOfRows;
+      var number_of_columns = rs_parser.numberOfColumns;
+      for (var i = 0; i < number_of_rows; i++) {
+        var row;
+        if (rowsAsArray) {
+          row = [];
+          for (var j = 0; j < number_of_columns; j++) {
+            row.push(rs_parser.readValue());
+          }
+        } else {
+          row = {};
+          for (var j = 0; j < number_of_columns; j++) {
+            if (nestTables && column_table_names[j]) {
+              if (row[column_table_names[j]] === void 0) {
+                row[column_table_names[j]] = {};
+              }
+              row[column_table_names[j]][column_names[j]] = rs_parser.readValue();
+            } else {
+              row[column_names[j]] = rs_parser.readValue();
+            }
+          }
+        }
+        rows.push(row);
+      }
+      rs_parser.verifyAtEnd();
+      return rows;
+    }
+    var ArgParser = class {
+      constructor(argv) {
+        this.argv = argv;
+        this.next_idx = 0;
+      }
+      // Return the next arg, skipping args that are null or undefined,
+      // return null if there is no more args
+      getNext() {
+        while (this.next_idx < this.argv.length) {
+          var next_arg = this.argv[this.next_idx++];
+          if (next_arg !== null && next_arg !== void 0) {
+            return next_arg;
+          }
+        }
+        return null;
+      }
+      // return what the next arg will be, but do NOT advance next_idx
+      peekNext() {
+        var save_next_idx = this.next_idx;
+        var peek_arg = this.getNext();
+        this.next_idx = save_next_idx;
+        return peek_arg;
+      }
+      // Helper for parseExecuteArgs to resolve ambiguity of first parameter being an
+      // object, which could be named bind parameters or could be options (yuck!)
+      // Return true if arg is bind parameters, false otherwise
+      isBindParameter(arg) {
+        if (arg === null) return false;
+        if (Array.isArray(arg)) {
+          return true;
+        }
+        if (typeof arg !== "object") {
+          return false;
+        }
+        var peek_arg = this.peekNext();
+        if (peek_arg !== null && typeof peek_arg === "object") {
+          return true;
+        }
+        if (arg.nestTables !== void 0 || arg.rowsAsArray !== void 0 || arg.queryTimeout !== void 0 || arg.communicationTimeout !== void 0 || arg.fastInternalRows !== void 0 || arg.returnMultipleResultSets !== void 0 || arg.vectorOutputType !== void 0) {
+          return false;
+        }
+        return true;
+      }
+      // parse params, options and cbfunc args common to
+      // Statement.execute and Connection.execute
+      parseExecuteArgs() {
+        this.params = null;
+        this.options = null;
+        this.cbfunc = null;
+        var arg = this.getNext();
+        if (this.isBindParameter(arg)) {
+          this.params = arg;
+          arg = this.getNext();
+        }
+        if (arg !== null && typeof arg === "object" && !Array.isArray(arg)) {
+          this.options = arg;
+          arg = this.getNext();
+        }
+        if (arg !== null && typeof arg === "function") {
+          this.cbfunc = arg;
+          arg = this.getNext();
+        }
+        if (arg !== null) {
+          while (arg !== null) {
+            if (typeof arg === "function") {
+              this.cbfunc = arg;
+              break;
+            }
+            arg = this.getNext();
+          }
+          throw new Error();
+        }
+      }
+    };
+    function StatementExec(stmt, p1, p2, p3, execType) {
+      var args = new ArgParser([p1, p2, p3]);
+      var parseError;
+      try {
+        args.parseExecuteArgs();
+      } catch (e) {
+        var methodName;
+        switch (execType) {
+          case 2:
+            methodName = "exec[ute]Batch";
+            break;
+          case 1:
+            methodName = "exec[ute]Query";
+            break;
+          default:
+          case 0:
+            methodName = "exec[ute]";
+            break;
+        }
+        parseError = new Error("Invalid parameter for function '" + methodName + "([params][, options][, callback])'");
+        parseError.code = -20002;
+        parseError.sqlState = "HY000";
+      }
+      var func;
+      switch (execType) {
+        case 2:
+          func = stmt.execBatchInternal;
+          break;
+        case 1:
+          func = stmt.execQueryInternal;
+          break;
+        case 0:
+        default:
+          func = stmt.execInternal;
+          break;
+      }
+      if (args.cbfunc) {
+        if (parseError) {
+          args.cbfunc(parseError);
+          return;
+        }
+        func.call(
+          stmt,
+          args.params,
+          args.options,
+          function StatementExecCallback(e, rows2) {
+            if (!e) {
+              if (Buffer.isBuffer(rows2)) {
+                try {
+                  rows2 = translateFromInternalResultSet(args.options, rows2);
+                } catch (err) {
+                  e = err;
+                  rows2 = null;
+                }
+              }
+            }
+            if (arguments.length == 2) {
+              args.cbfunc(e, rows2);
+            } else {
+              args.cbfunc(e);
+            }
+          }
+        );
+      } else {
+        if (parseError) {
+          throw parseError;
+        }
+        var rows = func.call(stmt, args.params, args.options, null);
+        if (Buffer.isBuffer(rows)) {
+          rows = translateFromInternalResultSet(args.options, rows);
+        }
+        return rows;
+      }
+    }
+    function dynamicallyAddStmtExecMethod(stmt) {
+      if (stmt.exec == null) {
+        stmt.exec = function(p1 = null, p2 = null, p3 = null) {
+          return StatementExec(this, p1, p2, p3, 0);
+        };
+      }
+      if (stmt.execute == null) {
+        stmt.execute = function(p1 = null, p2 = null, p3 = null) {
+          return StatementExec(this, p1, p2, p3, 0);
+        };
+      }
+      if (stmt.execQuery == null) {
+        stmt.execQuery = function(p1 = null, p2 = null, p3 = null) {
+          return StatementExec(this, p1, p2, p3, 1);
+        };
+      }
+      if (stmt.executeQuery == null) {
+        stmt.executeQuery = function(p1 = null, p2 = null, p3 = null) {
+          return StatementExec(this, p1, p2, p3, 1);
+        };
+      }
+      if (stmt.execBatch == null) {
+        stmt.execBatch = function(p1 = null, p2 = null, p3 = null) {
+          return StatementExec(this, p1, p2, p3, 2);
+        };
+      }
+      if (stmt.executeBatch == null) {
+        stmt.executeBatch = function(p1 = null, p2 = null, p3 = null) {
+          return StatementExec(this, p1, p2, p3, 2);
+        };
+      }
+    }
+    function isPropertyTrue(obj, key) {
+      if (typeof obj === "object" && obj !== null) {
+        const lowerKey = key.toLowerCase();
+        for (const prop in obj) {
+          if (prop.toLowerCase() === lowerKey) {
+            const value = obj[prop];
+            return value === true || typeof value === "string" && value.toLowerCase() === "true";
+          }
+        }
+      }
+      return false;
+    }
+    function ConnectionExec(conn, sql, p2, p3, p4) {
+      var args = new ArgParser([p2, p3, p4]);
+      var parseError;
+      try {
+        args.parseExecuteArgs();
+      } catch (e) {
+        parseError = new Error("Invalid parameter for function 'exec[ute](sql[, params][, options][, callback])'");
+        parseError.code = -20002;
+        parseError.sqlState = "HY000";
+      }
+      if (args.cbfunc) {
+        if (parseError) {
+          args.cbfunc(parseError);
+          return;
+        }
+        if (args.options !== void 0 && args.options !== null && isPropertyTrue(args.options, "returnMultipleResultSets")) {
+          const streamExt = require_Stream();
+          streamExt.executeMultipleResultSets(conn, sql, args.params, args.options, args.cbfunc);
+          return;
+        }
+        conn.execInternal(
+          sql,
+          args.params,
+          args.options,
+          function ConnectionExecCallback(e, rows2) {
+            if (!e) {
+              if (Buffer.isBuffer(rows2)) {
+                try {
+                  rows2 = translateFromInternalResultSet(args.options, rows2);
+                } catch (err) {
+                  e = err;
+                  rows2 = null;
+                }
+              }
+            }
+            if (arguments.length == 2) {
+              args.cbfunc(e, rows2);
+            } else {
+              args.cbfunc(e);
+            }
+          }
+        );
+      } else {
+        if (parseError) {
+          throw parseError;
+        }
+        var rows = conn.execInternal(sql, args.params, args.options, null);
+        if (Buffer.isBuffer(rows)) {
+          rows = translateFromInternalResultSet(args.options, rows);
+        }
+        return rows;
+      }
+    }
+    function dynamicallyAddConnExecMethod(conn) {
+      if (conn.exec == null) {
+        conn.exec = function(sql, p2 = null, p3 = null, p4 = null) {
+          return ConnectionExec(this, sql, p2, p3, p4);
+        };
+      }
+      if (conn.execute == null) {
+        conn.execute = function(sql, p2 = null, p3 = null, p4 = null) {
+          return ConnectionExec(this, sql, p2, p3, p4);
+        };
+      }
+    }
+    var modpath = path.dirname(__dirname);
+    var hanaDynatrace;
+    try {
+      hanaDynatrace = __require(path.join(modpath, "extension", "Dynatrace.js"));
+    } catch (ex) {
+      debug("Could not load Dynatrace.js:" + ex.message);
+    }
+    var hanaOpenTelemetry;
+    try {
+      hanaOpenTelemetry = __require(path.join(modpath, "extension", "OpenTelemetry.js"));
+    } catch (ex) {
+      debug("Could not load OpenTelemetry.js:" + ex.message);
+    }
+    function dynamicallyAddExtTraceWrappers(conn, host, port, tenant, allowOpenTelemetry, allowDynatrace) {
+      var destInfo = { host, port, tenant };
+      try {
+        if (allowOpenTelemetry && hanaOpenTelemetry && hanaOpenTelemetry.isOpenTelemetryEnabled()) {
+          hanaOpenTelemetry.openTelemetryConnection(conn, destInfo);
+          return;
+        }
+      } catch (ex) {
+        debug("Error in dynamicallyAddExtTraceWrappers for OpenTelemetry: " + ex.message);
+      }
+      try {
+        if (allowDynatrace && hanaDynatrace && hanaDynatrace.isDynatraceEnabled()) {
+          hanaDynatrace.dynatraceConnection(conn, destInfo);
+          return;
+        }
+      } catch (ex) {
+        debug("Error in dynamicallyAddExtTraceWrappers for Dynatrace: " + ex.message);
+      }
+    }
+    process.on("exit", function() {
+      db.__stopAllWork();
+    });
+    debug("Detected os.arch=" + os.arch() + ", process.platform=" + process.platform + ", process.arch=" + process.arch + ", process.version=" + process.version);
+    if (process.platform === "win32" && process.arch != "x64") {
+      debug("ERROR: On Windows, this driver only supports the x64 architecture. Your node process is: " + process.arch);
+      throw new Error("On Windows, this driver only supports the x64 architecture. Your node process is: " + process.arch);
+    }
+    if (majorVersion < 8) {
+      throw new Error("Node version " + process.version + " is unsupported by @sap/hana-client. Only versions >=8 are supported");
+    }
+    var pb_subdir = null;
+    var dbcapi_name = "libdbcapiHDB";
+    if (process.platform === "linux") {
+      if (isMusl()) {
+        pb_subdir = "linuxx86_64_alpine-gcc6";
+      } else if (process.arch === "x64") {
+        pb_subdir = "linuxx86_64-gcc6";
+      } else if (process.arch.toLowerCase().indexOf("ppc") != -1 && os.endianness() === "LE") {
+        pb_subdir = "linuxppc64le-gcc6";
+      } else if (process.arch === "arm64") {
+        pb_subdir = "linuxaarch64-gcc9";
+      } else {
+        pb_subdir = "unknown";
+      }
+    } else if (process.platform === "win32") {
+      pb_subdir = "ntamd64-msvc2022";
+    } else if (process.platform === "darwin") {
+      if (process.arch === "arm64") {
+        pb_subdir = "darwinarm64-xcode12";
+      } else {
+        pb_subdir = "darwinintel64-xcode7";
+      }
+    }
+    var pb_path = path.join(modpath, "prebuilt", pb_subdir);
+    var dll_path = pb_path;
+    var dbcapi = path.join(dll_path, dbcapi_name + extensions[process.platform]);
+    var removeDirectory = function(dir) {
+      if (fs.existsSync(dir)) {
+        fs.readdirSync(dir).forEach((file, index) => {
+          const curPath = path.join(dir, file);
+          if (fs.lstatSync(curPath).isDirectory()) {
+            removeDirectory(curPath);
+          } else {
+            fs.unlinkSync(curPath);
+          }
+        });
+        fs.rmdirSync(dir);
+      }
+    };
+    var getSubDirs = function(dir) {
+      const isDirectory = (source) => fs.lstatSync(source).isDirectory();
+      const getDirectories = (source) => fs.readdirSync(source).map((name2) => path.join(source, name2)).filter(isDirectory);
+      return getDirectories(dir);
+    };
+    if (process.env["HDB_NODE_PLATFORM_CLEAN"] === "1") {
+      pb_path_all = getSubDirs(path.join(modpath, "prebuilt"));
+      pb_path_all.forEach((pbPath) => {
+        if (pbPath !== pb_path) {
+          try {
+            removeDirectory(pbPath);
+          } catch (ex) {
+            debug(ex.message);
+            debug("Failed to remove unrelated native platform libraries in '" + pbPath + "'.");
+          }
+        }
+      });
+    } else if (process.env["HDB_NODEJS_INSTALL_PLATFORMS"]) {
+      keep = process.env["HDB_NODEJS_INSTALL_PLATFORMS"].split(",").map((name2) => path.join(modpath, "prebuilt", name2));
+      pb_path_all = getSubDirs(path.join(modpath, "prebuilt"));
+      pb_count = pb_path_all.length;
+      pb_path_all.forEach((pbPath) => {
+        if (keep.indexOf(pbPath) < 0) {
+          try {
+            removeDirectory(pbPath);
+            pb_count -= 1;
+          } catch (ex) {
+            debug(ex.message);
+            debug("Failed to remove unrelated native platform libraries in '" + pbPath + "'.");
+          }
+        }
+      });
+      if (pb_count <= 0) {
+        debug("WARNING: Environment variable HDB_NODEJS_INSTALL_PLATFORMS did not name any valid platforms. All native platform libraries have been removed.");
+      }
+    }
+    var pb_path_all;
+    var keep;
+    var pb_count;
+    var default_driver_file = "hana-client";
+    var driver_file = default_driver_file;
+    if (process.env["HDB_NODE_NO_NAPI_DRIVER"] === "1") {
+      v = process.version;
+      match = v.match(/v([0-9]+)\.([0-9]+)\.[0-9]+/);
+      driver_file += "_v" + match[1];
+      if (match[1] + 0 == 0) {
+        driver_file += "_" + match[2];
+      }
+    }
+    var v;
+    var match;
+    var driver_path = path.join(pb_path, driver_file + ".node");
+    try {
+      debug("Checking for existence of " + driver_path);
+      fs.statSync(driver_path);
+    } catch (ex) {
+      debug("Did not find " + driver_path);
+      driver_path = path.join(pb_path, default_driver_file + ".node");
+      try {
+        debug("Checking for existence of " + driver_path);
+        fs.statSync(driver_path);
+      } catch (ex2) {
+        debug("No prebuilt node driver found for platform: '" + process.platform + "', arch: '" + process.arch + "', endianness: '" + os.endianness() + "' for Node version: '" + process.version + "'");
+      }
+    }
+    debug("Attempting to load Hana node-hdbcapi driver");
+    var userbld_driver_path = path.join(modpath, "build", "Release", "hana-client.node");
+    debug("... Trying user-built copy...");
+    try {
+      debug("... Looking for user-built copy in " + userbld_driver_path + " ... ");
+      fs.statSync(userbld_driver_path);
+      debug("Found.");
+      try {
+        debug("... Attempting to load user-built copy... ");
+        db = __require(userbld_driver_path);
+        debug("Loaded.");
+      } catch (ex) {
+        debug(ex.message);
+        debug("Could not load: User-built copy did not satisfy requirements.");
+        throw ex;
+      }
+    } catch (ex) {
+      debug("Not found.");
+    }
+    if (db === null) {
+      debug("... Trying prebuilt copy...");
+      try {
+        debug("... Looking for prebuilt copy in " + driver_path + " ... ");
+        db = __require(driver_path);
+        debug("Loaded.");
+      } catch (ex) {
+        debug(ex.message);
+        debug("Could not load: Prebuilt copy did not satisfy requirements.");
+        debug("Could not load modules for Platform: '" + process.platform + "', Process Arch: '" + process.arch + "', and Version: '" + process.version + "'");
+        throw ex;
+      }
+    }
+    db.__loadDbcapi(dbcapi);
+    var pipeInfo = db.__getPipe();
+    setupPipe(pipeInfo);
+    db.__setAddFnsThatAddMethodsToObjects(
+      dynamicallyAddConnExecMethod,
+      dynamicallyAddStmtExecMethod,
+      dynamicallyAddExtTraceWrappers
+    );
+    if (db !== null) {
+      db.isDynatraceSupported = Boolean(hanaDynatrace);
+      db.isOpenTelemetrySupported = Boolean(hanaOpenTelemetry);
+      debug("Success.");
+    }
+    module.exports = db;
+  }
+});
+export default require_lib();
+//# sourceMappingURL=lib-J24D2XQX.js.map