sqlite-executor 4.0.1

package/dist/cjs/index.cjs

@@ -0,0 +1,3939 @@
+"use strict";
+var __webpack_require__ = {};
+!function() {
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+}();
+!function() {
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+}();
+!function() {
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+}();
+!function() {
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+}();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createTimeoutError: function() {
+        return createTimeoutError;
+    },
+    SQLiteExecutor: function() {
+        return executor_SQLiteExecutor;
+    },
+    VALID_TRANSACTION_MODES: function() {
+        return VALID_TRANSACTION_MODES;
+    },
+    DEFAULT_STATEMENT_TIMEOUT: function() {
+        return DEFAULT_STATEMENT_TIMEOUT;
+    },
+    Metrics: function() {
+        return metrics_Metrics;
+    }
+});
+var external_node_events_namespaceObject = require("node:events");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var _maxSize = /*#__PURE__*/ new WeakMap(), _maxKeyLength = /*#__PURE__*/ new WeakMap(), _map = /*#__PURE__*/ new WeakMap();
+var lruCache_LRUCache = /*#__PURE__*/ function() {
+    "use strict";
+    function LRUCache() {
+        var _ref = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, _ref_maxSize = _ref.maxSize, maxSize = void 0 === _ref_maxSize ? 256 : _ref_maxSize, _ref_maxKeyLength = _ref.maxKeyLength, maxKeyLength = void 0 === _ref_maxKeyLength ? 4096 : _ref_maxKeyLength;
+        _class_call_check(this, LRUCache);
+        _class_private_field_init(this, _maxSize, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _maxKeyLength, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _map, {
+            writable: true,
+            value: new Map()
+        });
+        _class_private_field_set(this, _maxSize, Math.max(1, maxSize));
+        _class_private_field_set(this, _maxKeyLength, maxKeyLength);
+    }
+    _create_class(LRUCache, [
+        {
+            key: "get",
+            value: function(key) {
+                if ("string" != typeof key || key.length > _class_private_field_get(this, _maxKeyLength)) return;
+                var value = _class_private_field_get(this, _map).get(key);
+                if (void 0 === value) return;
+                _class_private_field_get(this, _map)["delete"](key);
+                _class_private_field_get(this, _map).set(key, value);
+                return value;
+            }
+        },
+        {
+            key: "set",
+            value: function(key, value) {
+                if ("string" != typeof key || key.length > _class_private_field_get(this, _maxKeyLength)) return;
+                if (_class_private_field_get(this, _map).size >= _class_private_field_get(this, _maxSize)) {
+                    var firstKey = _class_private_field_get(this, _map).keys().next().value;
+                    _class_private_field_get(this, _map)["delete"](firstKey);
+                }
+                _class_private_field_get(this, _map).set(key, value);
+            }
+        },
+        {
+            key: "size",
+            get: function() {
+                return _class_private_field_get(this, _map).size;
+            }
+        },
+        {
+            key: "clear",
+            value: function() {
+                _class_private_field_get(this, _map).clear();
+            }
+        }
+    ]);
+    return LRUCache;
+}();
+var CC_SINGLE_QUOTE = 39;
+var CC_DOUBLE_QUOTE = 34;
+var CC_DASH = 45;
+var CC_SLASH = 47;
+var CC_STAR = 42;
+var CC_NEWLINE = 10;
+var CC_QUESTION = 63;
+var CC_SEMICOLON = 59;
+var CC_SPACE = 32;
+var STATE_NORMAL = 0;
+var STATE_SINGLE_QUOTE = 1;
+var STATE_DOUBLE_QUOTE = 2;
+var STATE_LINE_COMMENT = 3;
+var STATE_BLOCK_COMMENT = 4;
+var _normBuf = new Uint16Array(1024);
+var _normDecoder = new TextDecoder("utf-16le");
+var _normCache = new lruCache_LRUCache({
+    maxSize: 256,
+    maxKeyLength: 4096
+});
+function normalizeSQL(sql) {
+    var cached = _normCache.get(sql);
+    if (void 0 !== cached) return cached;
+    var len = sql.length;
+    var needed = len + 1;
+    if (_normBuf.length < needed) _normBuf = new Uint16Array(2 * needed);
+    var outCodes = _normBuf;
+    var writePos = 0;
+    var pendingSpace = false;
+    var state = STATE_NORMAL;
+    for(var i = 0; i < len; i++){
+        var code = sql.charCodeAt(i);
+        var nextCode = sql.charCodeAt(i + 1);
+        if (state === STATE_BLOCK_COMMENT) {
+            if (code === CC_STAR && nextCode === CC_SLASH) {
+                state = STATE_NORMAL;
+                i++;
+                if (writePos > 0) pendingSpace = true;
+            }
+            continue;
+        }
+        if (state === STATE_LINE_COMMENT) {
+            if (code === CC_NEWLINE) {
+                state = STATE_NORMAL;
+                if (writePos > 0) pendingSpace = true;
+            }
+            continue;
+        }
+        if (state === STATE_NORMAL) {
+            if (code === CC_DASH && nextCode === CC_DASH) {
+                state = STATE_LINE_COMMENT;
+                i++;
+                continue;
+            }
+            if (code === CC_SLASH && nextCode === CC_STAR) {
+                state = STATE_BLOCK_COMMENT;
+                i++;
+                continue;
+            }
+        }
+        if (32 === code || 9 === code || 10 === code || 11 === code || 12 === code || 13 === code) {
+            if (writePos > 0) pendingSpace = true;
+            continue;
+        }
+        if (pendingSpace && writePos > 0) {
+            outCodes[writePos++] = CC_SPACE;
+            pendingSpace = false;
+        }
+        outCodes[writePos++] = code;
+        if (state === STATE_NORMAL) {
+            if (code === CC_SINGLE_QUOTE) state = STATE_SINGLE_QUOTE;
+            else if (code === CC_DOUBLE_QUOTE) state = STATE_DOUBLE_QUOTE;
+            continue;
+        }
+        if (state === STATE_SINGLE_QUOTE) {
+            if (code === CC_SINGLE_QUOTE && nextCode === CC_SINGLE_QUOTE) {
+                outCodes[writePos++] = nextCode;
+                i++;
+                continue;
+            }
+            if (code === CC_SINGLE_QUOTE) state = STATE_NORMAL;
+            continue;
+        }
+        if (state === STATE_DOUBLE_QUOTE) {
+            if (code === CC_DOUBLE_QUOTE && nextCode === CC_DOUBLE_QUOTE) {
+                outCodes[writePos++] = nextCode;
+                i++;
+                continue;
+            }
+            if (code === CC_DOUBLE_QUOTE) state = STATE_NORMAL;
+        }
+    }
+    var result;
+    if (0 === writePos) result = ";";
+    else {
+        while(writePos > 0 && outCodes[writePos - 1] === CC_SEMICOLON)writePos--;
+        outCodes[writePos++] = CC_SEMICOLON;
+        result = _normDecoder.decode(outCodes.subarray(0, writePos));
+    }
+    _normCache.set(sql, result);
+    return result;
+}
+var DEFAULT_STATEMENT_TIMEOUT = 30000;
+function createTimeoutError(timeout, sql) {
+    return new Error("SQLite statement timed out after ".concat(timeout, "ms: ").concat(normalizeSQL(sql)));
+}
+function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+var CHAR_QUOTE = 34;
+var CHAR_BACKSLASH = 92;
+var CHAR_OPEN_BRACKET = 91;
+var CHAR_CLOSE_BRACKET = 93;
+var CHAR_OPEN_BRACE = 123;
+var CHAR_CLOSE_BRACE = 125;
+var CHAR_COMMA = 44;
+var CHAR_SPACE = 32;
+var CHAR_TAB = 9;
+var CHAR_LF = 10;
+var CHAR_CR = 13;
+function isWhitespaceCode(code) {
+    return code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_LF || code === CHAR_CR;
+}
+function createJsonValueParser(onValue) {
+    return {
+        buffer: "",
+        start: -1,
+        readPos: 0,
+        nesting: 0,
+        inString: false,
+        escaped: false,
+        feed: function(chunk) {
+            this.buffer += chunk;
+            var consumeUntil = 0;
+            for(var index = this.readPos; index < this.buffer.length; index++){
+                var code = this.buffer.charCodeAt(index);
+                if (-1 === this.start) {
+                    if (isWhitespaceCode(code)) continue;
+                    if (code !== CHAR_OPEN_BRACKET && code !== CHAR_OPEN_BRACE) continue;
+                    this.start = index;
+                    this.nesting = 1;
+                    this.inString = false;
+                    this.escaped = false;
+                    continue;
+                }
+                if (this.inString) {
+                    if (this.escaped) this.escaped = false;
+                    else if (code === CHAR_BACKSLASH) this.escaped = true;
+                    else if (code === CHAR_QUOTE) this.inString = false;
+                    continue;
+                }
+                if (code === CHAR_QUOTE) {
+                    this.inString = true;
+                    continue;
+                }
+                if (code === CHAR_OPEN_BRACKET || code === CHAR_OPEN_BRACE) {
+                    this.nesting++;
+                    continue;
+                }
+                if (code === CHAR_CLOSE_BRACKET || code === CHAR_CLOSE_BRACE) {
+                    this.nesting--;
+                    if (0 === this.nesting) {
+                        var raw = this.buffer.slice(this.start, index + 1);
+                        this.start = -1;
+                        onValue(raw);
+                        consumeUntil = index + 1;
+                    }
+                }
+            }
+            if (consumeUntil > 0) {
+                this.buffer = this.buffer.slice(consumeUntil);
+                this.readPos = 0;
+            } else this.readPos = this.buffer.length;
+        },
+        reset: function() {
+            this.buffer = "";
+            this.start = -1;
+            this.readPos = 0;
+            this.nesting = 0;
+            this.inString = false;
+            this.escaped = false;
+        }
+    };
+}
+function createRowStreamParser(onRow) {
+    return {
+        buffer: "",
+        started: false,
+        finished: false,
+        inString: false,
+        escaped: false,
+        elementStart: -1,
+        elementEnd: -1,
+        nesting: 0,
+        readPos: 0,
+        feed: function(chunk) {
+            if (this.finished) return chunk;
+            this.buffer += chunk;
+            var index = this.readPos;
+            while(index < this.buffer.length){
+                var code = this.buffer.charCodeAt(index);
+                if (!this.started) {
+                    if (isWhitespaceCode(code)) {
+                        index++;
+                        continue;
+                    }
+                    if (code !== CHAR_OPEN_BRACKET) {
+                        index++;
+                        continue;
+                    }
+                    this.started = true;
+                    index++;
+                    continue;
+                }
+                if (this.inString) {
+                    if (this.escaped) this.escaped = false;
+                    else if (code === CHAR_BACKSLASH) this.escaped = true;
+                    else if (code === CHAR_QUOTE) this.inString = false;
+                    index++;
+                    continue;
+                }
+                if (-1 === this.elementStart) {
+                    if (isWhitespaceCode(code) || code === CHAR_COMMA) {
+                        index++;
+                        continue;
+                    }
+                    if (code === CHAR_CLOSE_BRACKET) {
+                        this.finished = true;
+                        var leftover = this.buffer.slice(index + 1);
+                        this.buffer = "";
+                        this.readPos = 0;
+                        return leftover;
+                    }
+                    this.elementStart = index;
+                    this.elementEnd = -1;
+                    this.nesting = code === CHAR_OPEN_BRACE || code === CHAR_OPEN_BRACKET ? 1 : 0;
+                    this.inString = code === CHAR_QUOTE;
+                    index++;
+                    continue;
+                }
+                if (code === CHAR_QUOTE) {
+                    this.inString = true;
+                    index++;
+                    continue;
+                }
+                if (code === CHAR_OPEN_BRACE || code === CHAR_OPEN_BRACKET) {
+                    this.nesting++;
+                    index++;
+                    continue;
+                }
+                if (code === CHAR_CLOSE_BRACE || code === CHAR_CLOSE_BRACKET) {
+                    this.nesting--;
+                    if (0 === this.nesting) this.elementEnd = index + 1;
+                }
+                if (-1 !== this.elementEnd) {
+                    var lookAhead = index + 1;
+                    while(lookAhead < this.buffer.length && isWhitespaceCode(this.buffer.charCodeAt(lookAhead)))lookAhead++;
+                    if (lookAhead < this.buffer.length) {
+                        var delimiter = this.buffer.charCodeAt(lookAhead);
+                        if (delimiter === CHAR_COMMA || delimiter === CHAR_CLOSE_BRACKET) {
+                            onRow(this.buffer.slice(this.elementStart, this.elementEnd));
+                            this.buffer = this.buffer.slice(lookAhead + 1);
+                            this.elementStart = -1;
+                            this.elementEnd = -1;
+                            this.nesting = 0;
+                            if (delimiter === CHAR_CLOSE_BRACKET) {
+                                this.finished = true;
+                                var tail = this.buffer;
+                                this.buffer = "";
+                                this.readPos = 0;
+                                return tail;
+                            }
+                            index = 0;
+                            continue;
+                        }
+                    }
+                }
+                index++;
+            }
+            if (this.elementStart > 0) {
+                this.buffer = this.buffer.slice(this.elementStart);
+                if (-1 !== this.elementEnd) this.elementEnd -= this.elementStart;
+                this.elementStart = 0;
+            }
+            this.readPos = 0 === this.elementStart ? this.buffer.length : 0;
+            return "";
+        },
+        reset: function() {
+            this.buffer = "";
+            this.started = false;
+            this.finished = false;
+            this.inString = false;
+            this.escaped = false;
+            this.elementStart = -1;
+            this.elementEnd = -1;
+            this.nesting = 0;
+            this.readPos = 0;
+        }
+    };
+}
+var TOKEN_COLUMN = "__sqlite_executor_token__";
+var DEFAULT_BATCH_SIZE = 10;
+function stream_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function stream_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function stream_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function stream_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function stream_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function stream_class_private_field_get(receiver, privateMap) {
+    var descriptor = stream_class_extract_field_descriptor(receiver, privateMap, "get");
+    return stream_class_apply_descriptor_get(receiver, descriptor);
+}
+function stream_class_private_field_init(obj, privateMap, value) {
+    stream_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function stream_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = stream_class_extract_field_descriptor(receiver, privateMap, "set");
+    stream_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function stream_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function stream_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) stream_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) stream_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _type_of(obj) {
+    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var _computedKey;
+function setupStreamParser(task) {
+    var valueParser = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {
+        feed: function() {}
+    };
+    if ("stream" !== task.kind) return null;
+    var parser = createRowStreamParser(function(rawRow) {
+        if (task.consumerError) return;
+        try {
+            var row = JSON.parse(rawRow);
+            if ((void 0 === row ? "undefined" : _type_of(row)) === "object" && null !== row && TOKEN_COLUMN in row) return void valueParser.feed("[".concat(rawRow, "]"));
+            task.onRow(row);
+        } catch (error) {
+            task.consumerError = toError(error);
+        }
+    });
+    return parser;
+}
+_computedKey = Symbol.asyncIterator;
+var _buffer = /*#__PURE__*/ new WeakMap(), _done = /*#__PURE__*/ new WeakMap(), _error = /*#__PURE__*/ new WeakMap(), _pending = /*#__PURE__*/ new WeakMap();
+var _computedKey1 = _computedKey;
+var stream_AsyncRowBuffer = /*#__PURE__*/ function() {
+    "use strict";
+    function AsyncRowBuffer() {
+        stream_class_call_check(this, AsyncRowBuffer);
+        stream_class_private_field_init(this, _buffer, {
+            writable: true,
+            value: []
+        });
+        stream_class_private_field_init(this, _done, {
+            writable: true,
+            value: false
+        });
+        stream_class_private_field_init(this, _error, {
+            writable: true,
+            value: null
+        });
+        stream_class_private_field_init(this, _pending, {
+            writable: true,
+            value: null
+        });
+    }
+    stream_create_class(AsyncRowBuffer, [
+        {
+            key: "push",
+            value: function(row) {
+                if (stream_class_private_field_get(this, _pending)) {
+                    var resolve = stream_class_private_field_get(this, _pending).resolve;
+                    stream_class_private_field_set(this, _pending, null);
+                    resolve({
+                        value: row,
+                        done: false
+                    });
+                } else stream_class_private_field_get(this, _buffer).push(row);
+            }
+        },
+        {
+            key: "end",
+            value: function() {
+                stream_class_private_field_set(this, _done, true);
+                if (stream_class_private_field_get(this, _pending)) {
+                    var resolve = stream_class_private_field_get(this, _pending).resolve;
+                    stream_class_private_field_set(this, _pending, null);
+                    resolve({
+                        value: void 0,
+                        done: true
+                    });
+                }
+            }
+        },
+        {
+            key: "error",
+            value: function(err) {
+                stream_class_private_field_set(this, _error, err);
+                if (stream_class_private_field_get(this, _pending)) {
+                    var reject = stream_class_private_field_get(this, _pending).reject;
+                    stream_class_private_field_set(this, _pending, null);
+                    reject(err);
+                }
+            }
+        },
+        {
+            key: "next",
+            value: function() {
+                var _this = this;
+                if (stream_class_private_field_get(this, _buffer).length > 0) return Promise.resolve({
+                    value: stream_class_private_field_get(this, _buffer).shift(),
+                    done: false
+                });
+                if (stream_class_private_field_get(this, _done)) return Promise.resolve({
+                    value: void 0,
+                    done: true
+                });
+                if (stream_class_private_field_get(this, _error)) return Promise.reject(stream_class_private_field_get(this, _error));
+                return new Promise(function(resolve, reject) {
+                    stream_class_private_field_set(_this, _pending, {
+                        resolve: resolve,
+                        reject: reject
+                    });
+                });
+            }
+        },
+        {
+            key: "return",
+            value: function() {
+                stream_class_private_field_set(this, _done, true);
+                if (stream_class_private_field_get(this, _pending)) {
+                    var resolve = stream_class_private_field_get(this, _pending).resolve;
+                    stream_class_private_field_set(this, _pending, null);
+                    resolve({
+                        value: void 0,
+                        done: true
+                    });
+                }
+                return Promise.resolve({
+                    value: void 0,
+                    done: true
+                });
+            }
+        },
+        {
+            key: _computedKey1,
+            value: function() {
+                return this;
+            }
+        }
+    ]);
+    return AsyncRowBuffer;
+}();
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function transaction_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else transaction_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+var VALID_TRANSACTION_MODES = [
+    "DEFERRED",
+    "IMMEDIATE",
+    "EXCLUSIVE"
+];
+function createTransactionHandle(scopeId, executor) {
+    var handle = {
+        execute: function(sql) {
+            var params = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [], options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+            return executor.enqueue("execute", sql, params, options, scopeId);
+        },
+        query: function(sql) {
+            var params = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [], options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+            return executor.enqueue("query", sql, params, options, scopeId);
+        },
+        stream: function(sql) {
+            var params = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [], options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+            if (!Array.isArray(params)) throw new TypeError("params must be an array");
+            var buffer = new stream_AsyncRowBuffer();
+            executor.enqueue("stream", sql, params, _object_spread_props(_object_spread({}, options), {
+                onRow: function(row) {
+                    return buffer.push(row);
+                }
+            }), scopeId).then(function() {
+                return buffer.end();
+            }, function(err) {
+                return buffer.error(err);
+            });
+            return buffer;
+        }
+    };
+    return handle;
+}
+var external_node_child_process_namespaceObject = require("node:child_process");
+var external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+var external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+var external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+var isWindows = "win32" === external_node_os_default().platform();
+function isExecutable(filePath) {
+    try {
+        if (isWindows) return external_node_fs_default().statSync(filePath).isFile();
+        external_node_fs_default().accessSync(filePath, external_node_fs_default().constants.X_OK);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function getPathExts() {
+    if (!isWindows) return [
+        ""
+    ];
+    var ext = process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM;.PS1";
+    return ext.split(";").map(function(e) {
+        return e.toLowerCase();
+    });
+}
+function which(command) {
+    if (!command) return null;
+    var pathExts = getPathExts();
+    if (command.includes(external_node_path_default().sep)) {
+        var fullPath = external_node_path_default().resolve(command);
+        if (!isWindows) return isExecutable(fullPath) ? fullPath : null;
+        if (external_node_path_default().extname(fullPath)) return isExecutable(fullPath) ? fullPath : null;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+            for(var _iterator = pathExts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var ext = _step.value;
+                var file = fullPath + ext;
+                if (isExecutable(file)) return file;
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+            } finally{
+                if (_didIteratorError) throw _iteratorError;
+            }
+        }
+        return null;
+    }
+    var envPath = process.env.PATH || "";
+    var pathDirs = envPath.split(external_node_path_default().delimiter);
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+    try {
+        for(var _iterator1 = pathDirs[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var dir = _step1.value;
+            if (dir) if (isWindows) {
+                var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+                try {
+                    for(var _iterator2 = pathExts[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                        var ext1 = _step2.value;
+                        var file1 = external_node_path_default().join(dir, command + ext1);
+                        if (isExecutable(file1)) return file1;
+                    }
+                } catch (err) {
+                    _didIteratorError2 = true;
+                    _iteratorError2 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion2 && null != _iterator2["return"]) _iterator2["return"]();
+                    } finally{
+                        if (_didIteratorError2) throw _iteratorError2;
+                    }
+                }
+            } else {
+                var file2 = external_node_path_default().join(dir, command);
+                if (isExecutable(file2)) return file2;
+            }
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && null != _iterator1["return"]) _iterator1["return"]();
+        } finally{
+            if (_didIteratorError1) throw _iteratorError1;
+        }
+    }
+    return null;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function process_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function process_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function process_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function process_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function process_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function process_class_private_field_get(receiver, privateMap) {
+    var descriptor = process_class_extract_field_descriptor(receiver, privateMap, "get");
+    return process_class_apply_descriptor_get(receiver, descriptor);
+}
+function process_class_private_field_init(obj, privateMap, value) {
+    process_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function process_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = process_class_extract_field_descriptor(receiver, privateMap, "set");
+    process_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function process_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function process_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) process_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) process_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (1 & t[0]) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create(("function" == typeof Iterator ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), "function" == typeof Symbol && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v1) {
+            return step([
+                n,
+                v1
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = 2 & op[0] ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                2 & op[0],
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (6 === op[0] || 2 === op[0])) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (3 === op[0] && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (6 === op[0] && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (5 & op[0]) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var GRACEFUL_SHUTDOWN_TIMEOUT = 5000;
+var _binary = /*#__PURE__*/ new WeakMap(), _database = /*#__PURE__*/ new WeakMap(), _proc = /*#__PURE__*/ new WeakMap(), _initMode = /*#__PURE__*/ new WeakMap(), _draining = /*#__PURE__*/ new WeakMap();
+var process_ProcessManager = /*#__PURE__*/ function() {
+    "use strict";
+    function ProcessManager() {
+        var _ref = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, binary = _ref.binary, database = _ref.database, _ref_initMode = _ref.initMode, initMode = void 0 === _ref_initMode ? "wal" : _ref_initMode;
+        process_class_call_check(this, ProcessManager);
+        process_class_private_field_init(this, _binary, {
+            writable: true,
+            value: void 0
+        });
+        process_class_private_field_init(this, _database, {
+            writable: true,
+            value: void 0
+        });
+        process_class_private_field_init(this, _proc, {
+            writable: true,
+            value: null
+        });
+        process_class_private_field_init(this, _initMode, {
+            writable: true,
+            value: void 0
+        });
+        process_class_private_field_init(this, _draining, {
+            writable: true,
+            value: false
+        });
+        var _which;
+        process_class_private_field_set(this, _binary, null != (_which = which(binary)) ? _which : binary);
+        process_class_private_field_set(this, _database, database);
+        process_class_private_field_set(this, _initMode, initMode);
+    }
+    process_create_class(ProcessManager, [
+        {
+            key: "binary",
+            get: function() {
+                return process_class_private_field_get(this, _binary);
+            }
+        },
+        {
+            key: "process",
+            get: function() {
+                return process_class_private_field_get(this, _proc);
+            }
+        },
+        {
+            key: "start",
+            value: function() {
+                var _proc_stdin, _proc_stdout, _proc_stderr;
+                if (!process_class_private_field_get(this, _binary)) throw new Error("sqlite3 binary path is empty. Provide a valid --binary / binary option.");
+                if (!external_node_fs_default().existsSync(process_class_private_field_get(this, _binary))) throw new Error("sqlite3 binary not found: ".concat(process_class_private_field_get(this, _binary), ". Make sure sqlite3 is installed or provide a valid --binary / binary option."));
+                var args = [
+                    "-json"
+                ];
+                if (process_class_private_field_get(this, _database)) args.push(process_class_private_field_get(this, _database));
+                if (process_class_private_field_get(this, _database) && ":memory:" !== process_class_private_field_get(this, _database) && "wal" === process_class_private_field_get(this, _initMode)) {
+                    args.push("-cmd", "PRAGMA journal_mode=WAL;");
+                    args.push("-cmd", "PRAGMA busy_timeout=5000;");
+                }
+                var proc = (0, external_node_child_process_namespaceObject.spawn)(process_class_private_field_get(this, _binary), args, {
+                    stdio: "pipe",
+                    shell: false,
+                    windowsHide: true
+                });
+                null == (_proc_stdin = proc.stdin) || _proc_stdin.setDefaultEncoding("utf-8");
+                null == (_proc_stdout = proc.stdout) || _proc_stdout.setEncoding("utf-8");
+                null == (_proc_stderr = proc.stderr) || _proc_stderr.setEncoding("utf-8");
+                process_class_private_field_set(this, _proc, proc);
+                return proc;
+            }
+        },
+        {
+            key: "write",
+            value: function(data) {
+                var _this = this;
+                var _$_class_private_field_get;
+                var stream = null == (_$_class_private_field_get = process_class_private_field_get(this, _proc)) ? void 0 : _$_class_private_field_get.stdin;
+                if (!stream) return;
+                if (!stream.write(data) && !process_class_private_field_get(this, _draining)) {
+                    process_class_private_field_set(this, _draining, true);
+                    stream.once("drain", function() {
+                        process_class_private_field_set(_this, _draining, false);
+                    });
+                }
+            }
+        },
+        {
+            key: "gracefulShutdown",
+            value: function() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var proc, timer, _proc_stdin;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                proc = process_class_private_field_get(_this, _proc);
+                                if (!proc) return [
+                                    2
+                                ];
+                                timer = setTimeout(function() {
+                                    _this.kill();
+                                }, GRACEFUL_SHUTDOWN_TIMEOUT);
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    4,
+                                    5
+                                ]);
+                                null == (_proc_stdin = proc.stdin) || _proc_stdin.write(".quit\n");
+                                return [
+                                    4,
+                                    (0, external_node_events_namespaceObject.once)(proc, "close")
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                clearTimeout(timer);
+                                return [
+                                    7
+                                ];
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "kill",
+            value: function() {
+                var _proc_stdout, _proc_stderr, _proc_stdin;
+                var proc = process_class_private_field_get(this, _proc);
+                if (!proc) return null;
+                process_class_private_field_set(this, _proc, null);
+                process_class_private_field_set(this, _draining, false);
+                null == (_proc_stdout = proc.stdout) || _proc_stdout.removeAllListeners();
+                null == (_proc_stderr = proc.stderr) || _proc_stderr.removeAllListeners();
+                proc.removeAllListeners();
+                null == (_proc_stdin = proc.stdin) || _proc_stdin.destroy();
+                proc.kill();
+                return proc;
+            }
+        }
+    ]);
+    return ProcessManager;
+}();
+var _counter = 0;
+var _PREFIX = "__executor_end__";
+var _PID36 = process.pid.toString(36);
+function generateToken() {
+    return "".concat(_PREFIX).concat((_counter++).toString(36), "_").concat(_PID36);
+}
+function escape_type_of(obj) {
+    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function escapeValue(value) {
+    if ("string" == typeof value) return "'".concat(value.replace(/'/g, "''"), "'");
+    if (null == value) return "NULL";
+    if ("number" == typeof value || (void 0 === value ? "undefined" : escape_type_of(value)) === "bigint") return String(value);
+    if ("boolean" == typeof value) return value ? "TRUE" : "FALSE";
+    if (value instanceof Date) return "'".concat(value.toISOString(), "'");
+    throw new TypeError("Unsupported parameter type: ".concat(void 0 === value ? "undefined" : escape_type_of(value)));
+}
+var _interpCache = new lruCache_LRUCache({
+    maxSize: 256,
+    maxKeyLength: 4096
+});
+function _parseTemplate(sql) {
+    var segments = [];
+    var segStart = 0;
+    var state = STATE_NORMAL;
+    var stateStartPos = -1;
+    for(var pos = 0; pos < sql.length; pos++){
+        var code = sql.charCodeAt(pos);
+        if (state === STATE_NORMAL) {
+            if (code === CC_SINGLE_QUOTE) {
+                state = STATE_SINGLE_QUOTE;
+                stateStartPos = pos;
+                continue;
+            }
+            if (code === CC_DOUBLE_QUOTE) {
+                state = STATE_DOUBLE_QUOTE;
+                stateStartPos = pos;
+                continue;
+            }
+            if (code === CC_DASH && sql.charCodeAt(pos + 1) === CC_DASH) {
+                state = STATE_LINE_COMMENT;
+                pos++;
+                continue;
+            }
+            if (code === CC_SLASH && sql.charCodeAt(pos + 1) === CC_STAR) {
+                state = STATE_BLOCK_COMMENT;
+                stateStartPos = pos;
+                pos++;
+                continue;
+            }
+            if (code === CC_QUESTION) {
+                segments.push(sql.slice(segStart, pos));
+                segStart = pos + 1;
+            }
+            continue;
+        }
+        if (state === STATE_SINGLE_QUOTE) {
+            if (code === CC_SINGLE_QUOTE) {
+                if (sql.charCodeAt(pos + 1) === CC_SINGLE_QUOTE) {
+                    pos++;
+                    continue;
+                }
+                state = STATE_NORMAL;
+                stateStartPos = -1;
+            }
+            continue;
+        }
+        if (state === STATE_DOUBLE_QUOTE) {
+            if (code === CC_DOUBLE_QUOTE) {
+                if (sql.charCodeAt(pos + 1) === CC_DOUBLE_QUOTE) {
+                    pos++;
+                    continue;
+                }
+                state = STATE_NORMAL;
+                stateStartPos = -1;
+            }
+            continue;
+        }
+        if (state === STATE_LINE_COMMENT) {
+            if (code === CC_NEWLINE) state = STATE_NORMAL;
+            continue;
+        }
+        if (state === STATE_BLOCK_COMMENT) {
+            if (code === CC_STAR && sql.charCodeAt(pos + 1) === CC_SLASH) {
+                pos++;
+                state = STATE_NORMAL;
+                stateStartPos = -1;
+            }
+        }
+    }
+    if (state === STATE_SINGLE_QUOTE) throw new Error("Unterminated single-quoted string starting at position ".concat(stateStartPos + 1));
+    if (state === STATE_DOUBLE_QUOTE) throw new Error("Unterminated double-quoted identifier/string starting at position ".concat(stateStartPos + 1));
+    if (state === STATE_BLOCK_COMMENT) throw new Error("Unterminated block comment starting at position ".concat(stateStartPos + 1));
+    segments.push(sql.slice(segStart));
+    return {
+        segments: segments,
+        paramCount: segments.length - 1
+    };
+}
+function interpolateSQL(sql, params) {
+    if (!sql.includes("?")) {
+        if (params.length > 0) throw new Error("Too many parameters provided");
+        return sql;
+    }
+    var template = _interpCache.get(sql);
+    if (void 0 === template) {
+        template = _parseTemplate(sql);
+        _interpCache.set(sql, template);
+    }
+    var segments = template.segments, paramCount = template.paramCount;
+    if (params.length < paramCount) throw new Error("Too few parameters provided");
+    if (params.length > paramCount) throw new Error("Too many parameters provided");
+    if (0 === paramCount) return segments[0];
+    var parts = [
+        segments[0]
+    ];
+    for(var i = 0; i < params.length; i++){
+        parts.push(escapeValue(params[i]));
+        parts.push(segments[i + 1]);
+    }
+    return parts.join("");
+}
+var READ_ONLY_KINDS = new Set([
+    "SELECT",
+    "WITH",
+    "VALUES",
+    "EXPLAIN"
+]);
+var _classifyCache = new lruCache_LRUCache({
+    maxSize: 256,
+    maxKeyLength: 4096
+});
+function classifySingle(stmt) {
+    var trimmed = stmt.trim();
+    if (0 === trimmed.length) return "write";
+    var kind = trimmed.split(/\s+/)[0].toUpperCase();
+    return READ_ONLY_KINDS.has(kind) ? "read" : "write";
+}
+function classifySQL(sql) {
+    if ("string" != typeof sql || 0 === sql.trim().length) return "write";
+    var cached = _classifyCache.get(sql);
+    if (void 0 !== cached) return cached;
+    var trimmed = sql.trim();
+    var result;
+    if (trimmed.includes(";")) {
+        var stmts = trimmed.split(";");
+        result = "read";
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+            for(var _iterator = stmts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var stmt = _step.value;
+                if ("write" === classifySingle(stmt)) {
+                    result = "write";
+                    break;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+            } finally{
+                if (_didIteratorError) throw _iteratorError;
+            }
+        }
+    } else result = classifySingle(trimmed);
+    _classifyCache.set(sql, result);
+    return result;
+}
+function queue_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function queue_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function queue_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_apply_descriptor_update(receiver, descriptor) {
+    if (descriptor.set) {
+        if (!descriptor.get) throw new TypeError("attempted to read set only private field");
+        if (!("__destrWrapper" in descriptor)) descriptor.__destrWrapper = {
+            set value (v){
+                descriptor.set.call(receiver, v);
+            },
+            get value () {
+                return descriptor.get.call(receiver);
+            }
+        };
+        return descriptor.__destrWrapper;
+    }
+    if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+    return descriptor;
+}
+function queue_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function queue_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function queue_class_private_field_get(receiver, privateMap) {
+    var descriptor = queue_class_extract_field_descriptor(receiver, privateMap, "get");
+    return queue_class_apply_descriptor_get(receiver, descriptor);
+}
+function queue_class_private_field_init(obj, privateMap, value) {
+    queue_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function queue_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = queue_class_extract_field_descriptor(receiver, privateMap, "set");
+    queue_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_field_update(receiver, privateMap) {
+    var descriptor = queue_class_extract_field_descriptor(receiver, privateMap, "update");
+    return _class_apply_descriptor_update(receiver, descriptor);
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    queue_check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function queue_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function queue_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) queue_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) queue_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function queue_ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (1 & t[0]) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create(("function" == typeof Iterator ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), "function" == typeof Symbol && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v1) {
+            return step([
+                n,
+                v1
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = 2 & op[0] ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                2 & op[0],
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (6 === op[0] || 2 === op[0])) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (3 === op[0] && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (6 === op[0] && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (5 & op[0]) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var queue_computedKey;
+var INITIAL_CAPACITY = 16;
+var SHRINK_THRESHOLD = 256;
+queue_computedKey = Symbol.iterator;
+var _items = /*#__PURE__*/ new WeakMap(), _head = /*#__PURE__*/ new WeakMap(), _tail = /*#__PURE__*/ new WeakMap(), _size = /*#__PURE__*/ new WeakMap(), _mask = /*#__PURE__*/ new WeakMap(), _grow = /*#__PURE__*/ new WeakSet(), _shrinkIfNeeded = /*#__PURE__*/ new WeakSet();
+var queue_computedKey1 = queue_computedKey;
+var queue_Queue = /*#__PURE__*/ function() {
+    "use strict";
+    function Queue() {
+        queue_class_call_check(this, Queue);
+        _class_private_method_init(this, _grow);
+        _class_private_method_init(this, _shrinkIfNeeded);
+        queue_class_private_field_init(this, _items, {
+            writable: true,
+            value: new Array(INITIAL_CAPACITY)
+        });
+        queue_class_private_field_init(this, _head, {
+            writable: true,
+            value: 0
+        });
+        queue_class_private_field_init(this, _tail, {
+            writable: true,
+            value: 0
+        });
+        queue_class_private_field_init(this, _size, {
+            writable: true,
+            value: 0
+        });
+        queue_class_private_field_init(this, _mask, {
+            writable: true,
+            value: INITIAL_CAPACITY - 1
+        });
+    }
+    queue_create_class(Queue, [
+        {
+            key: "enqueue",
+            value: function(value) {
+                if (queue_class_private_field_get(this, _size) === queue_class_private_field_get(this, _items).length) _class_private_method_get(this, _grow, grow).call(this);
+                queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _tail)] = value;
+                queue_class_private_field_set(this, _tail, queue_class_private_field_get(this, _tail) + 1 & queue_class_private_field_get(this, _mask));
+                _class_private_field_update(this, _size).value++;
+            }
+        },
+        {
+            key: "dequeue",
+            value: function() {
+                if (0 === queue_class_private_field_get(this, _size)) return null;
+                var value = queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head)];
+                queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head)] = void 0;
+                queue_class_private_field_set(this, _head, queue_class_private_field_get(this, _head) + 1 & queue_class_private_field_get(this, _mask));
+                _class_private_field_update(this, _size).value--;
+                return value;
+            }
+        },
+        {
+            key: "clear",
+            value: function() {
+                queue_class_private_field_get(this, _items).fill(void 0);
+                queue_class_private_field_set(this, _head, 0);
+                queue_class_private_field_set(this, _tail, 0);
+                queue_class_private_field_set(this, _size, 0);
+                _class_private_method_get(this, _shrinkIfNeeded, shrinkIfNeeded).call(this);
+            }
+        },
+        {
+            key: "remove",
+            value: function(value) {
+                for(var i = 0; i < queue_class_private_field_get(this, _size); i++){
+                    var idx = queue_class_private_field_get(this, _head) + i & queue_class_private_field_get(this, _mask);
+                    if (queue_class_private_field_get(this, _items)[idx] === value) {
+                        for(var j = i; j < queue_class_private_field_get(this, _size) - 1; j++){
+                            var curr = queue_class_private_field_get(this, _head) + j & queue_class_private_field_get(this, _mask);
+                            var next = queue_class_private_field_get(this, _head) + j + 1 & queue_class_private_field_get(this, _mask);
+                            queue_class_private_field_get(this, _items)[curr] = queue_class_private_field_get(this, _items)[next];
+                        }
+                        queue_class_private_field_set(this, _tail, queue_class_private_field_get(this, _tail) - 1 & queue_class_private_field_get(this, _mask));
+                        queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _tail)] = void 0;
+                        _class_private_field_update(this, _size).value--;
+                        return true;
+                    }
+                }
+                return false;
+            }
+        },
+        {
+            key: "find",
+            value: function(predicate) {
+                for(var i = 0; i < queue_class_private_field_get(this, _size); i++){
+                    var value = queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head) + i & queue_class_private_field_get(this, _mask)];
+                    if (predicate(value)) return value;
+                }
+                return null;
+            }
+        },
+        {
+            key: "toArray",
+            value: function() {
+                var result = new Array(queue_class_private_field_get(this, _size));
+                for(var i = 0; i < queue_class_private_field_get(this, _size); i++)result[i] = queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head) + i & queue_class_private_field_get(this, _mask)];
+                return result;
+            }
+        },
+        {
+            key: "values",
+            value: function() {
+                var i;
+                return queue_ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            i = 0;
+                            _state.label = 1;
+                        case 1:
+                            if (!(i < queue_class_private_field_get(this, _size))) return [
+                                3,
+                                4
+                            ];
+                            return [
+                                4,
+                                queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head) + i & queue_class_private_field_get(this, _mask)]
+                            ];
+                        case 2:
+                            _state.sent();
+                            _state.label = 3;
+                        case 3:
+                            i++;
+                            return [
+                                3,
+                                1
+                            ];
+                        case 4:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            }
+        },
+        {
+            key: "peek",
+            value: function() {
+                return queue_class_private_field_get(this, _size) > 0 ? queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head)] : null;
+            }
+        },
+        {
+            key: "prependAll",
+            value: function(other) {
+                if (other.isEmpty()) return;
+                if (0 === queue_class_private_field_get(this, _size)) {
+                    var tmpItems = queue_class_private_field_get(this, _items);
+                    var tmpMask = queue_class_private_field_get(this, _mask);
+                    queue_class_private_field_set(this, _items, queue_class_private_field_get(other, _items));
+                    queue_class_private_field_set(this, _head, queue_class_private_field_get(other, _head));
+                    queue_class_private_field_set(this, _tail, queue_class_private_field_get(other, _tail));
+                    queue_class_private_field_set(this, _size, queue_class_private_field_get(other, _size));
+                    queue_class_private_field_set(this, _mask, queue_class_private_field_get(other, _mask));
+                    queue_class_private_field_set(other, _items, tmpItems);
+                    queue_class_private_field_set(other, _head, 0);
+                    queue_class_private_field_set(other, _tail, 0);
+                    queue_class_private_field_set(other, _size, 0);
+                    queue_class_private_field_set(other, _mask, tmpMask);
+                    return;
+                }
+                var totalSize = queue_class_private_field_get(this, _size) + queue_class_private_field_get(other, _size);
+                var newCap = queue_class_private_field_get(this, _items).length;
+                while(newCap < totalSize)newCap *= 2;
+                var newItems = new Array(newCap);
+                var writeIdx = 0;
+                for(var i = 0; i < queue_class_private_field_get(other, _size); i++)newItems[writeIdx++] = queue_class_private_field_get(other, _items)[queue_class_private_field_get(other, _head) + i & queue_class_private_field_get(other, _mask)];
+                for(var i1 = 0; i1 < queue_class_private_field_get(this, _size); i1++)newItems[writeIdx++] = queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head) + i1 & queue_class_private_field_get(this, _mask)];
+                queue_class_private_field_set(this, _items, newItems);
+                queue_class_private_field_set(this, _head, 0);
+                queue_class_private_field_set(this, _tail, totalSize);
+                queue_class_private_field_set(this, _size, totalSize);
+                queue_class_private_field_set(this, _mask, newCap - 1);
+                queue_class_private_field_get(other, _items).fill(void 0);
+                queue_class_private_field_set(other, _head, 0);
+                queue_class_private_field_set(other, _tail, 0);
+                queue_class_private_field_set(other, _size, 0);
+            }
+        },
+        {
+            key: queue_computedKey1,
+            value: function() {
+                return this.values();
+            }
+        },
+        {
+            key: "size",
+            get: function() {
+                return queue_class_private_field_get(this, _size);
+            }
+        },
+        {
+            key: "isEmpty",
+            value: function() {
+                return 0 === queue_class_private_field_get(this, _size);
+            }
+        }
+    ]);
+    return Queue;
+}();
+function grow() {
+    var oldMask = queue_class_private_field_get(this, _mask);
+    var newCap = 2 * queue_class_private_field_get(this, _items).length;
+    queue_class_private_field_set(this, _mask, newCap - 1);
+    if (0 === queue_class_private_field_get(this, _head)) {
+        queue_class_private_field_get(this, _items).length = newCap;
+        queue_class_private_field_set(this, _tail, queue_class_private_field_get(this, _size));
+    } else {
+        var newItems = new Array(newCap);
+        for(var i = 0; i < queue_class_private_field_get(this, _size); i++)newItems[i] = queue_class_private_field_get(this, _items)[queue_class_private_field_get(this, _head) + i & oldMask];
+        queue_class_private_field_set(this, _items, newItems);
+        queue_class_private_field_set(this, _head, 0);
+        queue_class_private_field_set(this, _tail, queue_class_private_field_get(this, _size));
+    }
+}
+function shrinkIfNeeded() {
+    if (queue_class_private_field_get(this, _items).length >= SHRINK_THRESHOLD) {
+        queue_class_private_field_set(this, _items, new Array(INITIAL_CAPACITY));
+        queue_class_private_field_set(this, _mask, INITIAL_CAPACITY - 1);
+    }
+}
+function buildPayload(sql, token) {
+    var _ref = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}, _ref_skipNormalize = _ref.skipNormalize, skipNormalize = void 0 === _ref_skipNormalize ? false : _ref_skipNormalize;
+    var normalized = skipNormalize ? sql : normalizeSQL(sql);
+    var suffix = normalized.endsWith(";") ? "" : ";";
+    return "".concat(normalized).concat(suffix, "\nSELECT '").concat(token, "' AS ").concat(TOKEN_COLUMN, ";\n");
+}
+function buildBatchPayload(batch) {
+    var useWalBatch = batch.length > 1 && batch.every(function(t) {
+        return "execute" === t.kind;
+    });
+    if (useWalBatch) {
+        var parts = [
+            "BEGIN;\n"
+        ];
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+            for(var _iterator = batch[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var task = _step.value;
+                parts.push(task.sql, "\n");
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+            } finally{
+                if (_didIteratorError) throw _iteratorError;
+            }
+        }
+        parts.push("COMMIT;\n");
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+        try {
+            for(var _iterator1 = batch[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var task1 = _step1.value;
+                parts.push("SELECT '".concat(task1.token, "' AS ").concat(TOKEN_COLUMN, ";\n"));
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && null != _iterator1["return"]) _iterator1["return"]();
+            } finally{
+                if (_didIteratorError1) throw _iteratorError1;
+            }
+        }
+        return parts.join("");
+    }
+    var parts1 = [];
+    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+    try {
+        for(var _iterator2 = batch[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+            var task2 = _step2.value;
+            parts1.push(buildPayload(task2.sql, task2.token, {
+                skipNormalize: true
+            }));
+        }
+    } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion2 && null != _iterator2["return"]) _iterator2["return"]();
+        } finally{
+            if (_didIteratorError2) throw _iteratorError2;
+        }
+    }
+    return parts1.join("");
+}
+function isSentinelRow(value, token) {
+    var _value_;
+    return Array.isArray(value) && 1 === value.length && (null == (_value_ = value[0]) ? void 0 : _value_[TOKEN_COLUMN]) === token;
+}
+function _array_like_to_array(arr, len) {
+    if (null == len || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if ("undefined" != typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if ("string" == typeof o) return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if ("Object" === n && o.constructor) n = o.constructor.name;
+    if ("Map" === n || "Set" === n) return Array.from(n);
+    if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function collectQueryRows(task, parsed) {
+    if (Array.isArray(parsed)) {
+        var _task_rows;
+        if (!task.rows) task.rows = [];
+        (_task_rows = task.rows).push.apply(_task_rows, _to_consumable_array(parsed));
+    }
+}
+function processStreamRows(task, parsed) {
+    if (!Array.isArray(parsed)) return;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+        for(var _iterator = parsed[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var row = _step.value;
+            if (task.consumerError) break;
+            try {
+                task.onRow(row);
+            } catch (error) {
+                task.consumerError = toError(error);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+        } finally{
+            if (_didIteratorError) throw _iteratorError;
+        }
+    }
+}
+function settleTask(task, error, value, metrics) {
+    var _ref = arguments.length > 4 && void 0 !== arguments[4] ? arguments[4] : {}, _ref_resetRowParser = _ref.resetRowParser, resetRowParser = void 0 === _ref_resetRowParser ? false : _ref_resetRowParser;
+    clearTimeout(task.timer);
+    if (resetRowParser) {
+        var _task_rowParser_reset, _task_rowParser;
+        null == (_task_rowParser = task.rowParser) || null == (_task_rowParser_reset = _task_rowParser.reset) || _task_rowParser_reset.call(_task_rowParser);
+    }
+    if (error) {
+        null == metrics || metrics.incrementTasksFailed();
+        task.reject(toError(error));
+        return;
+    }
+    var duration = task.startTime > 0 ? performance.now() - task.startTime : 0;
+    null == metrics || metrics.incrementTasksSuccess(duration);
+    task.resolve(value);
+}
+function taskWorker_array_like_to_array(arr, len) {
+    if (null == len || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function taskWorker_array_without_holes(arr) {
+    if (Array.isArray(arr)) return taskWorker_array_like_to_array(arr);
+}
+function taskWorker_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function taskWorker_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function taskWorker_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function taskWorker_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function taskWorker_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function taskWorker_class_private_field_get(receiver, privateMap) {
+    var descriptor = taskWorker_class_extract_field_descriptor(receiver, privateMap, "get");
+    return taskWorker_class_apply_descriptor_get(receiver, descriptor);
+}
+function taskWorker_class_private_field_init(obj, privateMap, value) {
+    taskWorker_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function taskWorker_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = taskWorker_class_extract_field_descriptor(receiver, privateMap, "set");
+    taskWorker_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function taskWorker_class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function taskWorker_class_private_method_init(obj, privateSet) {
+    taskWorker_check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function taskWorker_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function taskWorker_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) taskWorker_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) taskWorker_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function taskWorker_iterable_to_array(iter) {
+    if ("undefined" != typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) return Array.from(iter);
+}
+function taskWorker_non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function taskWorker_to_consumable_array(arr) {
+    return taskWorker_array_without_holes(arr) || taskWorker_iterable_to_array(arr) || taskWorker_unsupported_iterable_to_array(arr) || taskWorker_non_iterable_spread();
+}
+function taskWorker_unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if ("string" == typeof o) return taskWorker_array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if ("Object" === n && o.constructor) n = o.constructor.name;
+    if ("Map" === n || "Set" === n) return Array.from(n);
+    if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return taskWorker_array_like_to_array(o, minLen);
+}
+var _processManager = /*#__PURE__*/ new WeakMap(), _pendingQueue = /*#__PURE__*/ new WeakMap(), _inflightTasks = /*#__PURE__*/ new WeakMap(), _pendingFinalizeTasks = /*#__PURE__*/ new WeakMap(), _scheduledFinalize = /*#__PURE__*/ new WeakMap(), _valueParser = /*#__PURE__*/ new WeakMap(), _statementTimeout = /*#__PURE__*/ new WeakMap(), _logger = /*#__PURE__*/ new WeakMap(), _name = /*#__PURE__*/ new WeakMap(), _batchSize = /*#__PURE__*/ new WeakMap(), _metrics = /*#__PURE__*/ new WeakMap(), _startProcess = /*#__PURE__*/ new WeakSet(), _pumpQueue = /*#__PURE__*/ new WeakSet(), _handleParsedValue = /*#__PURE__*/ new WeakSet(), _scheduleFinalizeCheck = /*#__PURE__*/ new WeakSet(), _handleStderrChunk = /*#__PURE__*/ new WeakSet(), _handleTaskTimeout = /*#__PURE__*/ new WeakSet(), _settleTask = /*#__PURE__*/ new WeakSet(), _rejectAll = /*#__PURE__*/ new WeakSet();
+var taskWorker_TaskWorker = /*#__PURE__*/ function() {
+    "use strict";
+    function TaskWorker(param) {
+        var _this = this;
+        var binary = param.binary, database = param.database, statementTimeout = param.statementTimeout, logger = param.logger, name = param.name, initMode = param.initMode, _param_batchSize = param.batchSize, batchSize = void 0 === _param_batchSize ? DEFAULT_BATCH_SIZE : _param_batchSize, metrics = param.metrics;
+        taskWorker_class_call_check(this, TaskWorker);
+        taskWorker_class_private_method_init(this, _startProcess);
+        taskWorker_class_private_method_init(this, _pumpQueue);
+        taskWorker_class_private_method_init(this, _handleParsedValue);
+        taskWorker_class_private_method_init(this, _scheduleFinalizeCheck);
+        taskWorker_class_private_method_init(this, _handleStderrChunk);
+        taskWorker_class_private_method_init(this, _handleTaskTimeout);
+        taskWorker_class_private_method_init(this, _settleTask);
+        taskWorker_class_private_method_init(this, _rejectAll);
+        taskWorker_class_private_field_init(this, _processManager, {
+            writable: true,
+            value: void 0
+        });
+        taskWorker_class_private_field_init(this, _pendingQueue, {
+            writable: true,
+            value: new queue_Queue()
+        });
+        taskWorker_class_private_field_init(this, _inflightTasks, {
+            writable: true,
+            value: []
+        });
+        taskWorker_class_private_field_init(this, _pendingFinalizeTasks, {
+            writable: true,
+            value: new Set()
+        });
+        taskWorker_class_private_field_init(this, _scheduledFinalize, {
+            writable: true,
+            value: false
+        });
+        taskWorker_class_private_field_init(this, _valueParser, {
+            writable: true,
+            value: void 0
+        });
+        taskWorker_class_private_field_init(this, _statementTimeout, {
+            writable: true,
+            value: void 0
+        });
+        taskWorker_class_private_field_init(this, _logger, {
+            writable: true,
+            value: void 0
+        });
+        taskWorker_class_private_field_init(this, _name, {
+            writable: true,
+            value: void 0
+        });
+        taskWorker_class_private_field_init(this, _batchSize, {
+            writable: true,
+            value: void 0
+        });
+        taskWorker_class_private_field_init(this, _metrics, {
+            writable: true,
+            value: void 0
+        });
+        taskWorker_class_private_field_set(this, _name, null != name ? name : "worker");
+        taskWorker_class_private_field_set(this, _statementTimeout, statementTimeout);
+        taskWorker_class_private_field_set(this, _logger, logger);
+        taskWorker_class_private_field_set(this, _batchSize, batchSize);
+        taskWorker_class_private_field_set(this, _metrics, metrics);
+        taskWorker_class_private_field_set(this, _processManager, new process_ProcessManager({
+            binary: binary,
+            database: database,
+            initMode: initMode
+        }));
+        taskWorker_class_private_field_set(this, _valueParser, createJsonValueParser(function(raw) {
+            return taskWorker_class_private_method_get(_this, _handleParsedValue, handleParsedValue).call(_this, raw);
+        }));
+        taskWorker_class_private_method_get(this, _startProcess, startProcess).call(this);
+    }
+    taskWorker_create_class(TaskWorker, [
+        {
+            key: "name",
+            get: function() {
+                return taskWorker_class_private_field_get(this, _name);
+            }
+        },
+        {
+            key: "idle",
+            get: function() {
+                return 0 === taskWorker_class_private_field_get(this, _inflightTasks).length && taskWorker_class_private_field_get(this, _pendingQueue).isEmpty() && 0 === taskWorker_class_private_field_get(this, _pendingFinalizeTasks).size;
+            }
+        },
+        {
+            key: "pendingStatements",
+            get: function() {
+                return taskWorker_class_private_field_get(this, _pendingQueue).size + taskWorker_class_private_field_get(this, _inflightTasks).length + taskWorker_class_private_field_get(this, _pendingFinalizeTasks).size;
+            }
+        },
+        {
+            key: "enqueue",
+            value: function(config) {
+                var _$_class_private_field_get;
+                var _config_onRow;
+                var task = {
+                    kind: config.kind,
+                    sql: config.sql,
+                    timeout: config.timeout,
+                    token: config.token,
+                    resolve: config.resolve,
+                    reject: config.reject,
+                    rows: "query" === config.kind ? [] : void 0,
+                    onRow: null != (_config_onRow = config.onRow) ? _config_onRow : null,
+                    consumerError: null,
+                    stderrText: "",
+                    errorScheduled: false,
+                    timer: null,
+                    startTime: 0
+                };
+                null == (_$_class_private_field_get = taskWorker_class_private_field_get(this, _metrics)) || _$_class_private_field_get.incrementTasksTotal(config.kind);
+                taskWorker_class_private_field_get(this, _pendingQueue).enqueue(task);
+                taskWorker_class_private_method_get(this, _pumpQueue, pumpQueue).call(this);
+            }
+        },
+        {
+            key: "kill",
+            value: function() {
+                taskWorker_class_private_method_get(this, _rejectAll, taskWorker_rejectAll).call(this, new Error("".concat(taskWorker_class_private_field_get(this, _name), " is killed")));
+                taskWorker_class_private_field_get(this, _processManager).kill();
+            }
+        }
+    ]);
+    return TaskWorker;
+}();
+function startProcess() {
+    var _this = this;
+    var proc = taskWorker_class_private_field_get(this, _processManager).start();
+    proc.stdout.on("data", function(chunk) {
+        taskWorker_class_private_field_get(_this, _valueParser).feed(chunk);
+    });
+    proc.stderr.on("data", function(chunk) {
+        taskWorker_class_private_method_get(_this, _handleStderrChunk, taskWorker_handleStderrChunk).call(_this, chunk);
+    });
+    proc.on("error", function(error) {
+        var _class_private_field_get_error, _$_class_private_field_get;
+        if (taskWorker_class_private_field_get(_this, _processManager).process !== proc) return;
+        null == (_$_class_private_field_get = taskWorker_class_private_field_get(_this, _logger)) || null == (_class_private_field_get_error = _$_class_private_field_get.error) || _class_private_field_get_error.call(_$_class_private_field_get, "".concat(taskWorker_class_private_field_get(_this, _name), " process error"), error);
+        taskWorker_class_private_method_get(_this, _rejectAll, taskWorker_rejectAll).call(_this, toError(error));
+    });
+    proc.on("close", function(code, signal) {
+        if (taskWorker_class_private_field_get(_this, _processManager).process !== proc) return;
+        var err = new Error("".concat(taskWorker_class_private_field_get(_this, _name), " exited unexpectedly (code=").concat(code, ", signal=").concat(null != signal ? signal : "none", ")"));
+        taskWorker_class_private_method_get(_this, _rejectAll, taskWorker_rejectAll).call(_this, err);
+    });
+}
+function pumpQueue() {
+    var _this = this;
+    var _$_class_private_field_get;
+    var batch = [];
+    while(batch.length < taskWorker_class_private_field_get(this, _batchSize) && !taskWorker_class_private_field_get(this, _pendingQueue).isEmpty()){
+        var task = taskWorker_class_private_field_get(this, _pendingQueue).peek();
+        if ("stream" === task.kind && (batch.length > 0 || taskWorker_class_private_field_get(this, _inflightTasks).length > 0)) break;
+        taskWorker_class_private_field_get(this, _pendingQueue).dequeue();
+        batch.push(task);
+    }
+    if (0 === batch.length) return;
+    var now = performance.now();
+    var payload = buildBatchPayload(batch);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+        var _this1, _loop = function() {
+            var task = _step.value;
+            task.startTime = now;
+            var _task_timeout;
+            task.timer = setTimeout(function() {
+                return taskWorker_class_private_method_get(_this, _handleTaskTimeout, handleTaskTimeout).call(_this, task);
+            }, null != (_task_timeout = task.timeout) ? _task_timeout : taskWorker_class_private_field_get(_this1, _statementTimeout));
+        };
+        for(var _iterator = batch[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_this1 = this, _loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+        } finally{
+            if (_didIteratorError) throw _iteratorError;
+        }
+    }
+    (_$_class_private_field_get = taskWorker_class_private_field_get(this, _inflightTasks)).push.apply(_$_class_private_field_get, taskWorker_to_consumable_array(batch));
+    taskWorker_class_private_field_get(this, _processManager).write(payload);
+}
+function handleParsedValue(raw) {
+    var task = taskWorker_class_private_field_get(this, _inflightTasks)[0];
+    if (!task) return;
+    var parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        taskWorker_class_private_method_get(this, _rejectAll, taskWorker_rejectAll).call(this, new Error("Invalid JSON from sqlite3: ".concat(toError(error).message)));
+        return;
+    }
+    if (isSentinelRow(parsed, task.token)) {
+        clearTimeout(task.timer);
+        taskWorker_class_private_field_get(this, _inflightTasks).shift();
+        if (task.stderrText) {
+            taskWorker_class_private_method_get(this, _settleTask, settleTask1).call(this, task, new Error(task.stderrText.trim()), void 0);
+            taskWorker_class_private_method_get(this, _pumpQueue, pumpQueue).call(this);
+            return;
+        }
+        if (task.consumerError) {
+            taskWorker_class_private_method_get(this, _settleTask, settleTask1).call(this, task, task.consumerError, void 0);
+            taskWorker_class_private_method_get(this, _pumpQueue, pumpQueue).call(this);
+            return;
+        }
+        taskWorker_class_private_field_get(this, _pendingFinalizeTasks).add(task);
+        taskWorker_class_private_method_get(this, _scheduleFinalizeCheck, scheduleFinalizeCheck).call(this);
+        taskWorker_class_private_method_get(this, _pumpQueue, pumpQueue).call(this);
+        return;
+    }
+    if ("query" === task.kind) return void collectQueryRows(task, parsed);
+    if ("stream" === task.kind) processStreamRows(task, parsed);
+}
+function scheduleFinalizeCheck() {
+    var _this = this;
+    if (taskWorker_class_private_field_get(this, _scheduledFinalize)) return;
+    taskWorker_class_private_field_set(this, _scheduledFinalize, true);
+    setImmediate(function() {
+        taskWorker_class_private_field_set(_this, _scheduledFinalize, false);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+            for(var _iterator = taskWorker_class_private_field_get(_this, _pendingFinalizeTasks)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var task = _step.value;
+                if (task.stderrText) {
+                    taskWorker_class_private_method_get(_this, _settleTask, settleTask1).call(_this, task, new Error(task.stderrText.trim()), void 0);
+                    continue;
+                }
+                if (task.consumerError) {
+                    taskWorker_class_private_method_get(_this, _settleTask, settleTask1).call(_this, task, task.consumerError, void 0);
+                    continue;
+                }
+                if ("query" === task.kind) {
+                    taskWorker_class_private_method_get(_this, _settleTask, settleTask1).call(_this, task, null, task.rows);
+                    continue;
+                }
+                taskWorker_class_private_method_get(_this, _settleTask, settleTask1).call(_this, task, null, void 0);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+            } finally{
+                if (_didIteratorError) throw _iteratorError;
+            }
+        }
+        taskWorker_class_private_field_get(_this, _pendingFinalizeTasks).clear();
+        taskWorker_class_private_method_get(_this, _pumpQueue, pumpQueue).call(_this);
+    });
+}
+function taskWorker_handleStderrChunk(chunk) {
+    var _class_private_field_get_;
+    var task = null != (_class_private_field_get_ = taskWorker_class_private_field_get(this, _inflightTasks)[0]) ? _class_private_field_get_ : taskWorker_class_private_field_get(this, _pendingFinalizeTasks).values().next().value;
+    if (!task) {
+        var _class_private_field_get_error, _$_class_private_field_get;
+        null == (_$_class_private_field_get = taskWorker_class_private_field_get(this, _logger)) || null == (_class_private_field_get_error = _$_class_private_field_get.error) || _class_private_field_get_error.call(_$_class_private_field_get, String(chunk).trim());
+        return;
+    }
+    task.stderrText += String(chunk);
+}
+function handleTaskTimeout(task) {
+    var _$_class_private_field_get;
+    if (taskWorker_class_private_field_get(this, _inflightTasks)[0] !== task) return;
+    null == (_$_class_private_field_get = taskWorker_class_private_field_get(this, _metrics)) || _$_class_private_field_get.incrementTasksTimeout();
+    taskWorker_class_private_method_get(this, _rejectAll, taskWorker_rejectAll).call(this, createTimeoutError(task.timeout, task.sql));
+}
+function settleTask1(task, error, value) {
+    settleTask(task, error, value, taskWorker_class_private_field_get(this, _metrics));
+}
+function taskWorker_rejectAll(error) {
+    var all = taskWorker_class_private_field_get(this, _inflightTasks);
+    taskWorker_class_private_field_set(this, _inflightTasks, []);
+    var queued = taskWorker_class_private_field_get(this, _pendingQueue).dequeue();
+    while(queued){
+        taskWorker_class_private_method_get(this, _settleTask, settleTask1).call(this, queued, error, void 0);
+        queued = taskWorker_class_private_field_get(this, _pendingQueue).dequeue();
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+        for(var _iterator = all[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var task = _step.value;
+            taskWorker_class_private_method_get(this, _settleTask, settleTask1).call(this, task, error, void 0);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+        } finally{
+            if (_didIteratorError) throw _iteratorError;
+        }
+    }
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+    try {
+        for(var _iterator1 = taskWorker_class_private_field_get(this, _pendingFinalizeTasks)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var task1 = _step1.value;
+            taskWorker_class_private_method_get(this, _settleTask, settleTask1).call(this, task1, error, void 0);
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && null != _iterator1["return"]) _iterator1["return"]();
+        } finally{
+            if (_didIteratorError1) throw _iteratorError1;
+        }
+    }
+    taskWorker_class_private_field_get(this, _pendingFinalizeTasks).clear();
+}
+function readerPool_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function readerPool_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function readerPool_class_apply_descriptor_update(receiver, descriptor) {
+    if (descriptor.set) {
+        if (!descriptor.get) throw new TypeError("attempted to read set only private field");
+        if (!("__destrWrapper" in descriptor)) descriptor.__destrWrapper = {
+            set value (v){
+                descriptor.set.call(receiver, v);
+            },
+            get value () {
+                return descriptor.get.call(receiver);
+            }
+        };
+        return descriptor.__destrWrapper;
+    }
+    if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+    return descriptor;
+}
+function readerPool_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function readerPool_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function readerPool_class_private_field_get(receiver, privateMap) {
+    var descriptor = readerPool_class_extract_field_descriptor(receiver, privateMap, "get");
+    return readerPool_class_apply_descriptor_get(receiver, descriptor);
+}
+function readerPool_class_private_field_init(obj, privateMap, value) {
+    readerPool_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function readerPool_class_private_field_update(receiver, privateMap) {
+    var descriptor = readerPool_class_extract_field_descriptor(receiver, privateMap, "update");
+    return readerPool_class_apply_descriptor_update(receiver, descriptor);
+}
+function readerPool_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function readerPool_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) readerPool_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) readerPool_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var _workers = /*#__PURE__*/ new WeakMap(), _rrIndex = /*#__PURE__*/ new WeakMap();
+var readerPool_ReaderPool = /*#__PURE__*/ function() {
+    "use strict";
+    function ReaderPool(param) {
+        var binary = param.binary, database = param.database, poolSize = param.poolSize, statementTimeout = param.statementTimeout, logger = param.logger, metrics = param.metrics;
+        readerPool_class_call_check(this, ReaderPool);
+        readerPool_class_private_field_init(this, _workers, {
+            writable: true,
+            value: []
+        });
+        readerPool_class_private_field_init(this, _rrIndex, {
+            writable: true,
+            value: 0
+        });
+        for(var i = 0; i < poolSize; i++){
+            var worker = new taskWorker_TaskWorker({
+                binary: binary,
+                database: database,
+                statementTimeout: statementTimeout,
+                logger: logger,
+                metrics: metrics,
+                name: "reader-".concat(i),
+                initMode: ":memory:" !== database ? "none" : "wal"
+            });
+            readerPool_class_private_field_get(this, _workers).push(worker);
+        }
+    }
+    readerPool_create_class(ReaderPool, [
+        {
+            key: "size",
+            get: function() {
+                return readerPool_class_private_field_get(this, _workers).length;
+            }
+        },
+        {
+            key: "pendingStatements",
+            get: function() {
+                return readerPool_class_private_field_get(this, _workers).reduce(function(sum, w) {
+                    return sum + w.pendingStatements;
+                }, 0);
+            }
+        },
+        {
+            key: "enqueue",
+            value: function(task) {
+                var worker = readerPool_class_private_field_get(this, _workers)[readerPool_class_private_field_get(this, _rrIndex) % readerPool_class_private_field_get(this, _workers).length];
+                readerPool_class_private_field_update(this, _rrIndex).value++;
+                worker.enqueue(task);
+            }
+        },
+        {
+            key: "kill",
+            value: function() {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                try {
+                    for(var _iterator = readerPool_class_private_field_get(this, _workers)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var worker = _step.value;
+                        worker.kill();
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                    } finally{
+                        if (_didIteratorError) throw _iteratorError;
+                    }
+                }
+            }
+        }
+    ]);
+    return ReaderPool;
+}();
+function metrics_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function metrics_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function metrics_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function metrics_class_apply_descriptor_update(receiver, descriptor) {
+    if (descriptor.set) {
+        if (!descriptor.get) throw new TypeError("attempted to read set only private field");
+        if (!("__destrWrapper" in descriptor)) descriptor.__destrWrapper = {
+            set value (v){
+                descriptor.set.call(receiver, v);
+            },
+            get value () {
+                return descriptor.get.call(receiver);
+            }
+        };
+        return descriptor.__destrWrapper;
+    }
+    if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+    return descriptor;
+}
+function metrics_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function metrics_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function metrics_class_private_field_get(receiver, privateMap) {
+    var descriptor = metrics_class_extract_field_descriptor(receiver, privateMap, "get");
+    return metrics_class_apply_descriptor_get(receiver, descriptor);
+}
+function metrics_class_private_field_init(obj, privateMap, value) {
+    metrics_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function metrics_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = metrics_class_extract_field_descriptor(receiver, privateMap, "set");
+    metrics_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function metrics_class_private_field_update(receiver, privateMap) {
+    var descriptor = metrics_class_extract_field_descriptor(receiver, privateMap, "update");
+    return metrics_class_apply_descriptor_update(receiver, descriptor);
+}
+function metrics_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function metrics_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) metrics_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) metrics_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var _tasksTotal = /*#__PURE__*/ new WeakMap(), _tasksSuccess = /*#__PURE__*/ new WeakMap(), _tasksFailed = /*#__PURE__*/ new WeakMap(), _tasksTimeout = /*#__PURE__*/ new WeakMap(), _processRestarts = /*#__PURE__*/ new WeakMap(), _executeCount = /*#__PURE__*/ new WeakMap(), _queryCount = /*#__PURE__*/ new WeakMap(), _streamCount = /*#__PURE__*/ new WeakMap(), _totalDuration = /*#__PURE__*/ new WeakMap(), _startTime = /*#__PURE__*/ new WeakMap();
+var metrics_Metrics = /*#__PURE__*/ function() {
+    "use strict";
+    function Metrics() {
+        metrics_class_call_check(this, Metrics);
+        metrics_class_private_field_init(this, _tasksTotal, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _tasksSuccess, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _tasksFailed, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _tasksTimeout, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _processRestarts, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _executeCount, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _queryCount, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _streamCount, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _totalDuration, {
+            writable: true,
+            value: 0
+        });
+        metrics_class_private_field_init(this, _startTime, {
+            writable: true,
+            value: Date.now()
+        });
+    }
+    metrics_create_class(Metrics, [
+        {
+            key: "tasksTotal",
+            get: function() {
+                return metrics_class_private_field_get(this, _tasksTotal);
+            }
+        },
+        {
+            key: "tasksSuccess",
+            get: function() {
+                return metrics_class_private_field_get(this, _tasksSuccess);
+            }
+        },
+        {
+            key: "tasksFailed",
+            get: function() {
+                return metrics_class_private_field_get(this, _tasksFailed);
+            }
+        },
+        {
+            key: "tasksTimeout",
+            get: function() {
+                return metrics_class_private_field_get(this, _tasksTimeout);
+            }
+        },
+        {
+            key: "processRestarts",
+            get: function() {
+                return metrics_class_private_field_get(this, _processRestarts);
+            }
+        },
+        {
+            key: "executeCount",
+            get: function() {
+                return metrics_class_private_field_get(this, _executeCount);
+            }
+        },
+        {
+            key: "queryCount",
+            get: function() {
+                return metrics_class_private_field_get(this, _queryCount);
+            }
+        },
+        {
+            key: "streamCount",
+            get: function() {
+                return metrics_class_private_field_get(this, _streamCount);
+            }
+        },
+        {
+            key: "totalDuration",
+            get: function() {
+                return metrics_class_private_field_get(this, _totalDuration);
+            }
+        },
+        {
+            key: "startTime",
+            get: function() {
+                return metrics_class_private_field_get(this, _startTime);
+            }
+        },
+        {
+            key: "incrementTasksTotal",
+            value: function(kind) {
+                metrics_class_private_field_update(this, _tasksTotal).value++;
+                if ("execute" === kind) metrics_class_private_field_update(this, _executeCount).value++;
+                else if ("query" === kind) metrics_class_private_field_update(this, _queryCount).value++;
+                else if ("stream" === kind) metrics_class_private_field_update(this, _streamCount).value++;
+            }
+        },
+        {
+            key: "incrementTasksSuccess",
+            value: function(duration) {
+                metrics_class_private_field_update(this, _tasksSuccess).value++;
+                metrics_class_private_field_set(this, _totalDuration, metrics_class_private_field_get(this, _totalDuration) + duration);
+            }
+        },
+        {
+            key: "incrementTasksFailed",
+            value: function() {
+                metrics_class_private_field_update(this, _tasksFailed).value++;
+            }
+        },
+        {
+            key: "incrementTasksTimeout",
+            value: function() {
+                metrics_class_private_field_update(this, _tasksTimeout).value++;
+            }
+        },
+        {
+            key: "incrementProcessRestarts",
+            value: function() {
+                metrics_class_private_field_update(this, _processRestarts).value++;
+            }
+        },
+        {
+            key: "snapshot",
+            value: function() {
+                var elapsed = (Date.now() - metrics_class_private_field_get(this, _startTime)) / 1000;
+                return {
+                    tasksTotal: metrics_class_private_field_get(this, _tasksTotal),
+                    tasksSuccess: metrics_class_private_field_get(this, _tasksSuccess),
+                    tasksFailed: metrics_class_private_field_get(this, _tasksFailed),
+                    tasksTimeout: metrics_class_private_field_get(this, _tasksTimeout),
+                    processRestarts: metrics_class_private_field_get(this, _processRestarts),
+                    executeCount: metrics_class_private_field_get(this, _executeCount),
+                    queryCount: metrics_class_private_field_get(this, _queryCount),
+                    streamCount: metrics_class_private_field_get(this, _streamCount),
+                    avgQueryTime: metrics_class_private_field_get(this, _tasksSuccess) > 0 ? metrics_class_private_field_get(this, _totalDuration) / metrics_class_private_field_get(this, _tasksSuccess) : 0,
+                    qps: elapsed > 0 ? metrics_class_private_field_get(this, _tasksTotal) / elapsed : 0,
+                    uptime: elapsed
+                };
+            }
+        }
+    ]);
+    return Metrics;
+}();
+function transactionScope_asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function transactionScope_async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                transactionScope_asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                transactionScope_asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function transactionScope_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function transactionScope_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function transactionScope_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function transactionScope_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function transactionScope_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function transactionScope_class_private_field_get(receiver, privateMap) {
+    var descriptor = transactionScope_class_extract_field_descriptor(receiver, privateMap, "get");
+    return transactionScope_class_apply_descriptor_get(receiver, descriptor);
+}
+function transactionScope_class_private_field_init(obj, privateMap, value) {
+    transactionScope_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function transactionScope_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = transactionScope_class_extract_field_descriptor(receiver, privateMap, "set");
+    transactionScope_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function transactionScope_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function transactionScope_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) transactionScope_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) transactionScope_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function transactionScope_ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (1 & t[0]) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create(("function" == typeof Iterator ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), "function" == typeof Symbol && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v1) {
+            return step([
+                n,
+                v1
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = 2 & op[0] ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                2 & op[0],
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (6 === op[0] || 2 === op[0])) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (3 === op[0] && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (6 === op[0] && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (5 & op[0]) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var _deferredQueue = /*#__PURE__*/ new WeakMap(), _activeScopeId = /*#__PURE__*/ new WeakMap(), _scopeChain = /*#__PURE__*/ new WeakMap();
+var transactionScope_TransactionScope = /*#__PURE__*/ function() {
+    "use strict";
+    function TransactionScope() {
+        transactionScope_class_call_check(this, TransactionScope);
+        transactionScope_class_private_field_init(this, _deferredQueue, {
+            writable: true,
+            value: new queue_Queue()
+        });
+        transactionScope_class_private_field_init(this, _activeScopeId, {
+            writable: true,
+            value: null
+        });
+        transactionScope_class_private_field_init(this, _scopeChain, {
+            writable: true,
+            value: Promise.resolve()
+        });
+    }
+    transactionScope_create_class(TransactionScope, [
+        {
+            key: "scopeId",
+            get: function() {
+                return transactionScope_class_private_field_get(this, _activeScopeId);
+            }
+        },
+        {
+            key: "active",
+            get: function() {
+                return null !== transactionScope_class_private_field_get(this, _activeScopeId);
+            }
+        },
+        {
+            key: "pendingStatements",
+            get: function() {
+                return transactionScope_class_private_field_get(this, _deferredQueue).size;
+            }
+        },
+        {
+            key: "isDeferred",
+            value: function(scopeId) {
+                return null !== transactionScope_class_private_field_get(this, _activeScopeId) && transactionScope_class_private_field_get(this, _activeScopeId) !== scopeId;
+            }
+        },
+        {
+            key: "defer",
+            value: function(task) {
+                transactionScope_class_private_field_get(this, _deferredQueue).enqueue(task);
+            }
+        },
+        {
+            key: "enter",
+            value: function() {
+                var _this = this;
+                return transactionScope_async_to_generator(function() {
+                    var scopeId, release, gate, previous;
+                    return transactionScope_ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                scopeId = Symbol("transaction");
+                                release = null;
+                                gate = new Promise(function(resolve) {
+                                    release = resolve;
+                                });
+                                previous = transactionScope_class_private_field_get(_this, _scopeChain);
+                                transactionScope_class_private_field_set(_this, _scopeChain, previous["catch"](function() {}).then(function() {
+                                    return gate;
+                                }));
+                                return [
+                                    4,
+                                    previous["catch"](function() {})
+                                ];
+                            case 1:
+                                _state.sent();
+                                transactionScope_class_private_field_set(_this, _activeScopeId, scopeId);
+                                return [
+                                    2,
+                                    {
+                                        scopeId: scopeId,
+                                        release: release
+                                    }
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "exit",
+            value: function() {
+                transactionScope_class_private_field_set(this, _activeScopeId, null);
+            }
+        },
+        {
+            key: "restoreDeferred",
+            value: function(targetQueue) {
+                targetQueue.prependAll(transactionScope_class_private_field_get(this, _deferredQueue));
+            }
+        },
+        {
+            key: "rejectAll",
+            value: function(error) {
+                var task = transactionScope_class_private_field_get(this, _deferredQueue).dequeue();
+                while(task){
+                    settleTask(task, error, void 0, null);
+                    task = transactionScope_class_private_field_get(this, _deferredQueue).dequeue();
+                }
+            }
+        }
+    ]);
+    return TransactionScope;
+}();
+function pipelineEngine_array_like_to_array(arr, len) {
+    if (null == len || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function pipelineEngine_array_without_holes(arr) {
+    if (Array.isArray(arr)) return pipelineEngine_array_like_to_array(arr);
+}
+function pipelineEngine_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function pipelineEngine_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function pipelineEngine_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function pipelineEngine_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function pipelineEngine_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function pipelineEngine_class_private_field_get(receiver, privateMap) {
+    var descriptor = pipelineEngine_class_extract_field_descriptor(receiver, privateMap, "get");
+    return pipelineEngine_class_apply_descriptor_get(receiver, descriptor);
+}
+function pipelineEngine_class_private_field_init(obj, privateMap, value) {
+    pipelineEngine_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function pipelineEngine_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = pipelineEngine_class_extract_field_descriptor(receiver, privateMap, "set");
+    pipelineEngine_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function pipelineEngine_class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function pipelineEngine_class_private_method_init(obj, privateSet) {
+    pipelineEngine_check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function pipelineEngine_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function pipelineEngine_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) pipelineEngine_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) pipelineEngine_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function pipelineEngine_iterable_to_array(iter) {
+    if ("undefined" != typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) return Array.from(iter);
+}
+function pipelineEngine_non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function pipelineEngine_to_consumable_array(arr) {
+    return pipelineEngine_array_without_holes(arr) || pipelineEngine_iterable_to_array(arr) || pipelineEngine_unsupported_iterable_to_array(arr) || pipelineEngine_non_iterable_spread();
+}
+function pipelineEngine_unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if ("string" == typeof o) return pipelineEngine_array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if ("Object" === n && o.constructor) n = o.constructor.name;
+    if ("Map" === n || "Set" === n) return Array.from(n);
+    if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return pipelineEngine_array_like_to_array(o, minLen);
+}
+var _queue = /*#__PURE__*/ new WeakMap(), pipelineEngine_inflightTasks = /*#__PURE__*/ new WeakMap(), pipelineEngine_pendingFinalizeTasks = /*#__PURE__*/ new WeakMap(), pipelineEngine_scheduledFinalize = /*#__PURE__*/ new WeakMap(), _sharedValueParser = /*#__PURE__*/ new WeakMap(), pipelineEngine_processManager = /*#__PURE__*/ new WeakMap(), pipelineEngine_metrics = /*#__PURE__*/ new WeakMap(), pipelineEngine_statementTimeout = /*#__PURE__*/ new WeakMap(), pipelineEngine_logger = /*#__PURE__*/ new WeakMap(), pipelineEngine_batchSize = /*#__PURE__*/ new WeakMap(), _onTaskTimeout = /*#__PURE__*/ new WeakMap(), _active = /*#__PURE__*/ new WeakMap(), core_pipelineEngine_pumpQueue = /*#__PURE__*/ new WeakSet(), pipelineEngine_handleParsedValue = /*#__PURE__*/ new WeakSet(), core_pipelineEngine_scheduleFinalizeCheck = /*#__PURE__*/ new WeakSet(), pipelineEngine_settleTask = /*#__PURE__*/ new WeakSet();
+var pipelineEngine_PipelineEngine = /*#__PURE__*/ function() {
+    "use strict";
+    function PipelineEngine(processManager, param) {
+        var _this = this;
+        var metrics = param.metrics, statementTimeout = param.statementTimeout, logger = param.logger, _param_batchSize = param.batchSize, batchSize = void 0 === _param_batchSize ? DEFAULT_BATCH_SIZE : _param_batchSize, onTaskTimeout = param.onTaskTimeout;
+        pipelineEngine_class_call_check(this, PipelineEngine);
+        pipelineEngine_class_private_method_init(this, core_pipelineEngine_pumpQueue);
+        pipelineEngine_class_private_method_init(this, pipelineEngine_handleParsedValue);
+        pipelineEngine_class_private_method_init(this, core_pipelineEngine_scheduleFinalizeCheck);
+        pipelineEngine_class_private_method_init(this, pipelineEngine_settleTask);
+        pipelineEngine_class_private_field_init(this, _queue, {
+            writable: true,
+            value: new queue_Queue()
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_inflightTasks, {
+            writable: true,
+            value: []
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_pendingFinalizeTasks, {
+            writable: true,
+            value: new Set()
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_scheduledFinalize, {
+            writable: true,
+            value: false
+        });
+        pipelineEngine_class_private_field_init(this, _sharedValueParser, {
+            writable: true,
+            value: void 0
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_processManager, {
+            writable: true,
+            value: void 0
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_metrics, {
+            writable: true,
+            value: void 0
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_statementTimeout, {
+            writable: true,
+            value: void 0
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_logger, {
+            writable: true,
+            value: void 0
+        });
+        pipelineEngine_class_private_field_init(this, pipelineEngine_batchSize, {
+            writable: true,
+            value: void 0
+        });
+        pipelineEngine_class_private_field_init(this, _onTaskTimeout, {
+            writable: true,
+            value: void 0
+        });
+        pipelineEngine_class_private_field_init(this, _active, {
+            writable: true,
+            value: false
+        });
+        pipelineEngine_class_private_field_set(this, pipelineEngine_processManager, processManager);
+        pipelineEngine_class_private_field_set(this, pipelineEngine_metrics, metrics);
+        pipelineEngine_class_private_field_set(this, pipelineEngine_statementTimeout, statementTimeout);
+        pipelineEngine_class_private_field_set(this, pipelineEngine_logger, logger);
+        pipelineEngine_class_private_field_set(this, pipelineEngine_batchSize, batchSize);
+        pipelineEngine_class_private_field_set(this, _onTaskTimeout, null != onTaskTimeout ? onTaskTimeout : function() {});
+        pipelineEngine_class_private_field_set(this, _sharedValueParser, createJsonValueParser(function(raw) {
+            return pipelineEngine_class_private_method_get(_this, pipelineEngine_handleParsedValue, core_pipelineEngine_handleParsedValue).call(_this, raw);
+        }));
+    }
+    pipelineEngine_create_class(PipelineEngine, [
+        {
+            key: "mainQueue",
+            get: function() {
+                return pipelineEngine_class_private_field_get(this, _queue);
+            }
+        },
+        {
+            key: "pump",
+            value: function() {
+                pipelineEngine_class_private_method_get(this, core_pipelineEngine_pumpQueue, pipelineEngine_pumpQueue).call(this);
+            }
+        },
+        {
+            key: "pendingStatements",
+            get: function() {
+                return pipelineEngine_class_private_field_get(this, _queue).size + pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks).length + pipelineEngine_class_private_field_get(this, pipelineEngine_pendingFinalizeTasks).size;
+            }
+        },
+        {
+            key: "feed",
+            value: function(raw) {
+                pipelineEngine_class_private_field_get(this, _sharedValueParser).feed(raw);
+            }
+        },
+        {
+            key: "activate",
+            value: function() {
+                var _$_class_private_field_get;
+                null == (_$_class_private_field_get = pipelineEngine_class_private_field_get(this, _sharedValueParser)) || _$_class_private_field_get.reset();
+                pipelineEngine_class_private_field_set(this, _active, true);
+            }
+        },
+        {
+            key: "deactivate",
+            value: function() {
+                pipelineEngine_class_private_field_set(this, _active, false);
+            }
+        },
+        {
+            key: "enqueue",
+            value: function(task) {
+                pipelineEngine_class_private_field_get(this, _queue).enqueue(task);
+                pipelineEngine_class_private_method_get(this, core_pipelineEngine_pumpQueue, pipelineEngine_pumpQueue).call(this);
+            }
+        },
+        {
+            key: "handleStdoutChunk",
+            value: function(chunk) {
+                var task = pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks)[0];
+                if (!task) return;
+                if ("stream" === task.kind && task.rowParser && !task.rowParser.finished) {
+                    var leftover = task.rowParser.feed(chunk);
+                    if (leftover) pipelineEngine_class_private_field_get(this, _sharedValueParser).feed(leftover);
+                    return;
+                }
+                pipelineEngine_class_private_field_get(this, _sharedValueParser).feed(chunk);
+            }
+        },
+        {
+            key: "handleStderrChunk",
+            value: function(chunk) {
+                var _class_private_field_get_values_next_value;
+                var task = null != (_class_private_field_get_values_next_value = pipelineEngine_class_private_field_get(this, pipelineEngine_pendingFinalizeTasks).values().next().value) ? _class_private_field_get_values_next_value : pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks)[0];
+                if (!task) {
+                    var _class_private_field_get_error, _$_class_private_field_get;
+                    null == (_$_class_private_field_get = pipelineEngine_class_private_field_get(this, pipelineEngine_logger)) || null == (_class_private_field_get_error = _$_class_private_field_get.error) || _class_private_field_get_error.call(_$_class_private_field_get, String(chunk).trim());
+                    return;
+                }
+                task.stderrText += String(chunk);
+            }
+        },
+        {
+            key: "rejectAll",
+            value: function(error) {
+                var all = pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks);
+                pipelineEngine_class_private_field_set(this, pipelineEngine_inflightTasks, []);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                try {
+                    for(var _iterator = all[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var task = _step.value;
+                        pipelineEngine_class_private_method_get(this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(this, task, error, void 0);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                    } finally{
+                        if (_didIteratorError) throw _iteratorError;
+                    }
+                }
+                var queued = pipelineEngine_class_private_field_get(this, _queue).dequeue();
+                while(queued){
+                    pipelineEngine_class_private_method_get(this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(this, queued, error, void 0);
+                    queued = pipelineEngine_class_private_field_get(this, _queue).dequeue();
+                }
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+                try {
+                    for(var _iterator1 = pipelineEngine_class_private_field_get(this, pipelineEngine_pendingFinalizeTasks)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var task1 = _step1.value;
+                        pipelineEngine_class_private_method_get(this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(this, task1, error, void 0);
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && null != _iterator1["return"]) _iterator1["return"]();
+                    } finally{
+                        if (_didIteratorError1) throw _iteratorError1;
+                    }
+                }
+                pipelineEngine_class_private_field_get(this, pipelineEngine_pendingFinalizeTasks).clear();
+            }
+        },
+        {
+            key: "kill",
+            value: function() {
+                pipelineEngine_class_private_field_set(this, _active, false);
+                this.rejectAll(new Error("PipelineEngine is killed"));
+            }
+        }
+    ]);
+    return PipelineEngine;
+}();
+function pipelineEngine_pumpQueue() {
+    var _this = this;
+    var _$_class_private_field_get;
+    if (!pipelineEngine_class_private_field_get(this, _active)) return;
+    var batch = [];
+    while(batch.length < pipelineEngine_class_private_field_get(this, pipelineEngine_batchSize) && !pipelineEngine_class_private_field_get(this, _queue).isEmpty()){
+        var task = pipelineEngine_class_private_field_get(this, _queue).peek();
+        if ("stream" === task.kind && (batch.length > 0 || pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks).length > 0)) break;
+        pipelineEngine_class_private_field_get(this, _queue).dequeue();
+        batch.push(task);
+    }
+    if (0 === batch.length) return;
+    var now = performance.now();
+    var payload = buildBatchPayload(batch);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+        var _loop = function() {
+            var task = _step.value;
+            task.startTime = now;
+            task.timer = setTimeout(function() {
+                if (pipelineEngine_class_private_field_get(_this, pipelineEngine_inflightTasks)[0] !== task) return;
+                pipelineEngine_class_private_field_get(_this, _onTaskTimeout).call(_this, task);
+            }, task.timeout);
+        };
+        for(var _iterator = batch[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+        } finally{
+            if (_didIteratorError) throw _iteratorError;
+        }
+    }
+    (_$_class_private_field_get = pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks)).push.apply(_$_class_private_field_get, pipelineEngine_to_consumable_array(batch));
+    pipelineEngine_class_private_field_get(this, pipelineEngine_processManager).write(payload);
+}
+function core_pipelineEngine_handleParsedValue(raw) {
+    var task = pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks)[0];
+    if (!task) return;
+    var parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        this.rejectAll(new Error("Invalid JSON from sqlite3: ".concat(toError(error).message)));
+        return;
+    }
+    if (isSentinelRow(parsed, task.token)) {
+        clearTimeout(task.timer);
+        pipelineEngine_class_private_field_get(this, pipelineEngine_inflightTasks).shift();
+        if (task.consumerError) {
+            pipelineEngine_class_private_method_get(this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(this, task, task.consumerError, void 0);
+            pipelineEngine_class_private_method_get(this, core_pipelineEngine_pumpQueue, pipelineEngine_pumpQueue).call(this);
+            return;
+        }
+        pipelineEngine_class_private_field_get(this, pipelineEngine_pendingFinalizeTasks).add(task);
+        pipelineEngine_class_private_method_get(this, core_pipelineEngine_scheduleFinalizeCheck, pipelineEngine_scheduleFinalizeCheck).call(this);
+        pipelineEngine_class_private_method_get(this, core_pipelineEngine_pumpQueue, pipelineEngine_pumpQueue).call(this);
+        return;
+    }
+    if ("query" === task.kind) return void collectQueryRows(task, parsed);
+    if ("stream" === task.kind) processStreamRows(task, parsed);
+}
+function pipelineEngine_scheduleFinalizeCheck() {
+    var _this = this;
+    if (pipelineEngine_class_private_field_get(this, pipelineEngine_scheduledFinalize)) return;
+    pipelineEngine_class_private_field_set(this, pipelineEngine_scheduledFinalize, true);
+    setImmediate(function() {
+        pipelineEngine_class_private_field_set(_this, pipelineEngine_scheduledFinalize, false);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+            for(var _iterator = pipelineEngine_class_private_field_get(_this, pipelineEngine_pendingFinalizeTasks)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var task = _step.value;
+                if (task.stderrText) {
+                    pipelineEngine_class_private_method_get(_this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(_this, task, new Error(task.stderrText.trim()), void 0);
+                    continue;
+                }
+                if (task.consumerError) {
+                    pipelineEngine_class_private_method_get(_this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(_this, task, task.consumerError, void 0);
+                    continue;
+                }
+                if ("query" === task.kind) {
+                    pipelineEngine_class_private_method_get(_this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(_this, task, null, task.rows);
+                    continue;
+                }
+                pipelineEngine_class_private_method_get(_this, pipelineEngine_settleTask, pipelineEngine_settleTask1).call(_this, task, null, void 0);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+            } finally{
+                if (_didIteratorError) throw _iteratorError;
+            }
+        }
+        pipelineEngine_class_private_field_get(_this, pipelineEngine_pendingFinalizeTasks).clear();
+    });
+}
+function pipelineEngine_settleTask1(task, error, value) {
+    settleTask(task, error, value, pipelineEngine_class_private_field_get(this, pipelineEngine_metrics), {
+        resetRowParser: true
+    });
+}
+function executor_asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function executor_async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                executor_asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                executor_asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function executor_check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function executor_class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function executor_class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function executor_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function executor_class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function executor_class_private_field_get(receiver, privateMap) {
+    var descriptor = executor_class_extract_field_descriptor(receiver, privateMap, "get");
+    return executor_class_apply_descriptor_get(receiver, descriptor);
+}
+function executor_class_private_field_init(obj, privateMap, value) {
+    executor_check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function executor_class_private_field_set(receiver, privateMap, value) {
+    var descriptor = executor_class_extract_field_descriptor(receiver, privateMap, "set");
+    executor_class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function executor_class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function executor_class_private_method_init(obj, privateSet) {
+    executor_check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function executor_defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function executor_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) executor_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) executor_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function executor_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function executor_object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            executor_define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function executor_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function executor_object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else executor_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+function executor_ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (1 & t[0]) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create(("function" == typeof Iterator ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), "function" == typeof Symbol && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v1) {
+            return step([
+                n,
+                v1
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = 2 & op[0] ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                2 & op[0],
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (6 === op[0] || 2 === op[0])) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (3 === op[0] && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (6 === op[0] && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (5 & op[0]) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var executor_computedKey;
+executor_computedKey = Symbol.asyncDispose;
+var _closed = /*#__PURE__*/ new WeakMap(), executor_proc = /*#__PURE__*/ new WeakMap(), executor_logger = /*#__PURE__*/ new WeakMap(), executor_statementTimeout = /*#__PURE__*/ new WeakMap(), _autoRestart = /*#__PURE__*/ new WeakMap(), _fatalError = /*#__PURE__*/ new WeakMap(), executor_processManager = /*#__PURE__*/ new WeakMap(), _readerPool = /*#__PURE__*/ new WeakMap(), _poolSize = /*#__PURE__*/ new WeakMap(), executor_binary = /*#__PURE__*/ new WeakMap(), executor_database = /*#__PURE__*/ new WeakMap(), executor_metrics = /*#__PURE__*/ new WeakMap(), _pipeline = /*#__PURE__*/ new WeakMap(), _txScope = /*#__PURE__*/ new WeakMap(), _normalizeTimeout = /*#__PURE__*/ new WeakSet(), executor_startProcess = /*#__PURE__*/ new WeakSet(), _enqueue = /*#__PURE__*/ new WeakSet(), _enqueueWriter = /*#__PURE__*/ new WeakSet(), _enqueueReader = /*#__PURE__*/ new WeakSet(), _handleProcessFailure = /*#__PURE__*/ new WeakSet();
+var _computedKey2 = executor_computedKey;
+var executor_SQLiteExecutor = /*#__PURE__*/ function() {
+    "use strict";
+    function SQLiteExecutor() {
+        var _this = this;
+        var _ref = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, _ref_binary = _ref.binary, binary = void 0 === _ref_binary ? "sqlite3" : _ref_binary, _ref_database = _ref.database, database = void 0 === _ref_database ? ":memory:" : _ref_database, logger = _ref.logger, _ref_statementTimeout = _ref.statementTimeout, statementTimeout = void 0 === _ref_statementTimeout ? DEFAULT_STATEMENT_TIMEOUT : _ref_statementTimeout, _ref_autoRestart = _ref.autoRestart, autoRestart = void 0 === _ref_autoRestart ? true : _ref_autoRestart, _ref_poolSize = _ref.poolSize, poolSize = void 0 === _ref_poolSize ? 0 : _ref_poolSize, metrics = _ref.metrics;
+        executor_class_call_check(this, SQLiteExecutor);
+        executor_class_private_method_init(this, _normalizeTimeout);
+        executor_class_private_method_init(this, executor_startProcess);
+        executor_class_private_method_init(this, _enqueue);
+        executor_class_private_method_init(this, _enqueueWriter);
+        executor_class_private_method_init(this, _enqueueReader);
+        executor_class_private_method_init(this, _handleProcessFailure);
+        executor_class_private_field_init(this, _closed, {
+            writable: true,
+            value: false
+        });
+        executor_class_private_field_init(this, executor_proc, {
+            writable: true,
+            value: null
+        });
+        executor_class_private_field_init(this, executor_logger, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, executor_statementTimeout, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, _autoRestart, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, _fatalError, {
+            writable: true,
+            value: null
+        });
+        executor_class_private_field_init(this, executor_processManager, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, _readerPool, {
+            writable: true,
+            value: null
+        });
+        executor_class_private_field_init(this, _poolSize, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, executor_binary, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, executor_database, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, executor_metrics, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, _pipeline, {
+            writable: true,
+            value: void 0
+        });
+        executor_class_private_field_init(this, _txScope, {
+            writable: true,
+            value: new transactionScope_TransactionScope()
+        });
+        executor_class_private_field_set(this, executor_logger, logger);
+        executor_class_private_field_set(this, executor_statementTimeout, executor_class_private_method_get(this, _normalizeTimeout, normalizeTimeout).call(this, statementTimeout));
+        executor_class_private_field_set(this, _autoRestart, false !== autoRestart);
+        executor_class_private_field_set(this, executor_binary, binary);
+        executor_class_private_field_set(this, executor_database, database);
+        executor_class_private_field_set(this, _poolSize, poolSize);
+        executor_class_private_field_set(this, executor_metrics, null != metrics ? metrics : new metrics_Metrics());
+        executor_class_private_field_set(this, executor_processManager, new process_ProcessManager({
+            binary: binary,
+            database: database
+        }));
+        executor_class_private_field_set(this, _pipeline, new pipelineEngine_PipelineEngine(executor_class_private_field_get(this, executor_processManager), {
+            metrics: executor_class_private_field_get(this, executor_metrics),
+            statementTimeout: executor_class_private_field_get(this, executor_statementTimeout),
+            logger: executor_class_private_field_get(this, executor_logger),
+            onTaskTimeout: function(task) {
+                executor_class_private_field_get(_this, executor_metrics).incrementTasksTimeout();
+                executor_class_private_method_get(_this, _handleProcessFailure, handleProcessFailure).call(_this, createTimeoutError(task.timeout, task.sql));
+            }
+        }));
+        executor_class_private_method_get(this, executor_startProcess, core_executor_startProcess).call(this);
+        if (poolSize > 0 && ":memory:" !== database) executor_class_private_field_set(this, _readerPool, new readerPool_ReaderPool({
+            binary: binary,
+            database: database,
+            poolSize: poolSize,
+            statementTimeout: statementTimeout,
+            logger: logger,
+            metrics: executor_class_private_field_get(this, executor_metrics)
+        }));
+    }
+    executor_create_class(SQLiteExecutor, [
+        {
+            key: "pendingStatements",
+            get: function() {
+                var _$_class_private_field_get;
+                var _class_private_field_get_pendingStatements;
+                return executor_class_private_field_get(this, _txScope).pendingStatements + executor_class_private_field_get(this, _pipeline).pendingStatements + (null != (_class_private_field_get_pendingStatements = null == (_$_class_private_field_get = executor_class_private_field_get(this, _readerPool)) ? void 0 : _$_class_private_field_get.pendingStatements) ? _class_private_field_get_pendingStatements : 0);
+            }
+        },
+        {
+            key: "readerPool",
+            get: function() {
+                return executor_class_private_field_get(this, _readerPool);
+            }
+        },
+        {
+            key: "metrics",
+            get: function() {
+                return executor_class_private_field_get(this, executor_metrics);
+            }
+        },
+        {
+            key: "execute",
+            value: function(sql) {
+                var params = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [], options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+                var _this = this;
+                return executor_async_to_generator(function() {
+                    return executor_ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    executor_class_private_method_get(_this, _enqueue, executor_enqueue).call(_this, "execute", sql, params, options, null)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "query",
+            value: function(sql) {
+                var params = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [], options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+                return executor_class_private_method_get(this, _enqueue, executor_enqueue).call(this, "query", sql, params, options, null);
+            }
+        },
+        {
+            key: "stream",
+            value: function(sql) {
+                var params = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [], options = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
+                if (!Array.isArray(params)) throw new TypeError("params must be an array");
+                var buffer = new stream_AsyncRowBuffer();
+                executor_class_private_method_get(this, _enqueue, executor_enqueue).call(this, "stream", sql, params, executor_object_spread_props(executor_object_spread({}, options), {
+                    onRow: function(row) {
+                        return buffer.push(row);
+                    }
+                }), null).then(function() {
+                    return buffer.end();
+                }, function(err) {
+                    return buffer.error(err);
+                });
+                return buffer;
+            }
+        },
+        {
+            key: "transaction",
+            value: function(fn) {
+                var options = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
+                var _this = this;
+                return executor_async_to_generator(function() {
+                    var _options_mode, mode, _ref, scopeId, release, tx, result, error;
+                    return executor_ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                mode = null != (_options_mode = null == options ? void 0 : options.mode) ? _options_mode : "DEFERRED";
+                                if (!VALID_TRANSACTION_MODES.includes(mode)) throw new TypeError("transaction mode must be one of: ".concat(VALID_TRANSACTION_MODES.join(", ")));
+                                return [
+                                    4,
+                                    executor_class_private_field_get(_this, _txScope).enter()
+                                ];
+                            case 1:
+                                _ref = _state.sent(), scopeId = _ref.scopeId, release = _ref.release;
+                                tx = createTransactionHandle(scopeId, {
+                                    enqueue: function(kind, sql, params, options, sid) {
+                                        return executor_class_private_method_get(_this, _enqueue, executor_enqueue).call(_this, kind, sql, params, options, sid);
+                                    }
+                                });
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    ,
+                                    10,
+                                    11
+                                ]);
+                                return [
+                                    4,
+                                    tx.execute("BEGIN ".concat(mode))
+                                ];
+                            case 3:
+                                _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                _state.trys.push([
+                                    4,
+                                    7,
+                                    ,
+                                    9
+                                ]);
+                                return [
+                                    4,
+                                    fn(tx)
+                                ];
+                            case 5:
+                                result = _state.sent();
+                                return [
+                                    4,
+                                    tx.execute("COMMIT")
+                                ];
+                            case 6:
+                                _state.sent();
+                                return [
+                                    2,
+                                    result
+                                ];
+                            case 7:
+                                error = _state.sent();
+                                return [
+                                    4,
+                                    tx.execute("ROLLBACK")["catch"](function() {})
+                                ];
+                            case 8:
+                                _state.sent();
+                                throw error;
+                            case 9:
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 10:
+                                executor_class_private_field_get(_this, _txScope).exit();
+                                executor_class_private_field_get(_this, _txScope).restoreDeferred(executor_class_private_field_get(_this, _pipeline).mainQueue);
+                                executor_class_private_field_get(_this, _pipeline).pump();
+                                release();
+                                return [
+                                    7
+                                ];
+                            case 11:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "close",
+            value: function() {
+                var _this = this;
+                return executor_async_to_generator(function() {
+                    var _$_class_private_field_get;
+                    return executor_ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (executor_class_private_field_get(_this, _closed)) return [
+                                    2
+                                ];
+                                executor_class_private_field_set(_this, _closed, true);
+                                executor_class_private_field_get(_this, _pipeline).kill();
+                                executor_class_private_field_get(_this, _txScope).rejectAll(new Error("SQLiteExecutor is closed"));
+                                null == (_$_class_private_field_get = executor_class_private_field_get(_this, _readerPool)) || _$_class_private_field_get.kill();
+                                return [
+                                    4,
+                                    executor_class_private_field_get(_this, executor_processManager).gracefulShutdown()
+                                ];
+                            case 1:
+                                _state.sent();
+                                executor_class_private_field_get(_this, executor_processManager).kill();
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    (0, external_node_events_namespaceObject.once)(executor_class_private_field_get(_this, executor_processManager).process, "close")
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: _computedKey2,
+            value: function() {
+                this.close();
+            }
+        }
+    ]);
+    return SQLiteExecutor;
+}();
+function normalizeTimeout(value) {
+    if (!Number.isInteger(value) || value <= 0) throw new TypeError("statementTimeout must be a positive integer");
+    return value;
+}
+function core_executor_startProcess() {
+    var _this = this;
+    var _proc_stderr;
+    var proc;
+    try {
+        proc = executor_class_private_field_get(this, executor_processManager).start();
+    } catch (error) {
+        var _class_private_field_get_error, _$_class_private_field_get;
+        executor_class_private_field_set(this, _fatalError, toError(error));
+        null == (_$_class_private_field_get = executor_class_private_field_get(this, executor_logger)) || null == (_class_private_field_get_error = _$_class_private_field_get.error) || _class_private_field_get_error.call(_$_class_private_field_get, "failed to start sqlite3 process", executor_class_private_field_get(this, _fatalError));
+        return;
+    }
+    if (!proc.stdout) {
+        executor_class_private_field_set(this, _fatalError, new Error("Failed to spawn sqlite3 process: stdio unavailable (binary=".concat(executor_class_private_field_get(this, executor_binary), ")")));
+        executor_class_private_field_get(this, executor_processManager).kill();
+        return;
+    }
+    proc.stdout.on("data", function(chunk) {
+        executor_class_private_field_get(_this, _pipeline).handleStdoutChunk(chunk);
+    });
+    null == (_proc_stderr = proc.stderr) || _proc_stderr.on("data", function(chunk) {
+        executor_class_private_field_get(_this, _pipeline).handleStderrChunk(chunk);
+    });
+    proc.on("error", function(error) {
+        var _class_private_field_get_error, _$_class_private_field_get;
+        if (executor_class_private_field_get(_this, executor_proc) !== proc) return;
+        null == (_$_class_private_field_get = executor_class_private_field_get(_this, executor_logger)) || null == (_class_private_field_get_error = _$_class_private_field_get.error) || _class_private_field_get_error.call(_$_class_private_field_get, "sqlite3 process error", error);
+        executor_class_private_method_get(_this, _handleProcessFailure, handleProcessFailure).call(_this, error);
+    });
+    proc.on("close", function(code, signal) {
+        if (executor_class_private_field_get(_this, executor_proc) !== proc) return;
+        if (executor_class_private_field_get(_this, _closed)) return;
+        executor_class_private_method_get(_this, _handleProcessFailure, handleProcessFailure).call(_this, new Error("sqlite3 process exited unexpectedly (code=".concat(code, ", signal=").concat(null != signal ? signal : "none", ")")));
+    });
+    executor_class_private_field_set(this, executor_proc, proc);
+    executor_class_private_field_get(this, _pipeline).activate();
+}
+function executor_enqueue(kind, sql, params, options, scopeId) {
+    if (executor_class_private_field_get(this, _closed)) return Promise.reject(new Error("SQLiteExecutor is closed"));
+    if (executor_class_private_field_get(this, _fatalError)) return Promise.reject(executor_class_private_field_get(this, _fatalError));
+    if (!Array.isArray(params)) return Promise.reject(new TypeError("params must be an array"));
+    var _options_timeout;
+    var timeout = null != (_options_timeout = null == options ? void 0 : options.timeout) ? _options_timeout : executor_class_private_field_get(this, executor_statementTimeout);
+    var token = generateToken();
+    var _options_onRow;
+    var onRow = null != (_options_onRow = null == options ? void 0 : options.onRow) ? _options_onRow : null;
+    var normalized = normalizeSQL(sql);
+    var formatted;
+    var sqlNormalized = true;
+    formatted = 0 !== params.length || normalized.includes("?") ? interpolateSQL(normalized, params) : normalized;
+    if (scopeId) return executor_class_private_method_get(this, _enqueueWriter, enqueueWriter).call(this, kind, formatted, timeout, token, onRow, scopeId, sqlNormalized);
+    if (executor_class_private_field_get(this, _readerPool)) {
+        if ("stream" === kind || "query" === kind) return executor_class_private_method_get(this, _enqueueReader, enqueueReader).call(this, kind, formatted, timeout, token, onRow);
+        if ("execute" === kind && "read" === classifySQL(normalized)) return executor_class_private_method_get(this, _enqueueReader, enqueueReader).call(this, kind, formatted, timeout, token, onRow);
+    }
+    return executor_class_private_method_get(this, _enqueueWriter, enqueueWriter).call(this, kind, formatted, timeout, token, onRow, null, sqlNormalized);
+}
+function enqueueWriter(kind, sql, timeout, token, onRow, scopeId) {
+    var _this = this;
+    var sqlNormalized = arguments.length > 6 && void 0 !== arguments[6] ? arguments[6] : false;
+    executor_class_private_field_get(this, executor_metrics).incrementTasksTotal(kind);
+    return new Promise(function(resolve, reject) {
+        var task = {
+            kind: kind,
+            sql: sql,
+            timeout: timeout,
+            token: token,
+            onRow: onRow,
+            scopeId: scopeId,
+            sqlNormalized: sqlNormalized,
+            resolve: resolve,
+            reject: reject,
+            consumerError: null,
+            stderrText: "",
+            timer: null,
+            startTime: 0,
+            rowParser: null
+        };
+        if ("query" === kind) task.rows = [];
+        if ("stream" === kind) task.rowParser = setupStreamParser(task, executor_class_private_field_get(_this, _pipeline));
+        if (executor_class_private_field_get(_this, _txScope).isDeferred(scopeId)) executor_class_private_field_get(_this, _txScope).defer(task);
+        else executor_class_private_field_get(_this, _pipeline).enqueue(task);
+    });
+}
+function enqueueReader(kind, sql, timeout, token, onRow) {
+    var _this = this;
+    return new Promise(function(resolve, reject) {
+        executor_class_private_field_get(_this, _readerPool).enqueue({
+            kind: kind,
+            sql: sql,
+            timeout: timeout,
+            token: token,
+            onRow: onRow,
+            resolve: resolve,
+            reject: reject
+        });
+    });
+}
+function handleProcessFailure(error) {
+    var failure = toError(error);
+    executor_class_private_field_get(this, executor_processManager).kill();
+    executor_class_private_field_set(this, executor_proc, null);
+    executor_class_private_field_get(this, _pipeline).deactivate();
+    executor_class_private_field_get(this, _pipeline).rejectAll(failure);
+    executor_class_private_field_get(this, _txScope).rejectAll(failure);
+    if (!executor_class_private_field_get(this, _closed) && executor_class_private_field_get(this, _autoRestart)) {
+        executor_class_private_field_get(this, executor_metrics).incrementProcessRestarts();
+        executor_class_private_method_get(this, executor_startProcess, core_executor_startProcess).call(this);
+        return;
+    }
+    executor_class_private_field_set(this, _fatalError, failure);
+    executor_class_private_field_set(this, _closed, true);
+}
+exports.DEFAULT_STATEMENT_TIMEOUT = __webpack_exports__.DEFAULT_STATEMENT_TIMEOUT;
+exports.Metrics = __webpack_exports__.Metrics;
+exports.SQLiteExecutor = __webpack_exports__.SQLiteExecutor;
+exports.VALID_TRANSACTION_MODES = __webpack_exports__.VALID_TRANSACTION_MODES;
+exports.createTimeoutError = __webpack_exports__.createTimeoutError;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_STATEMENT_TIMEOUT",
+    "Metrics",
+    "SQLiteExecutor",
+    "VALID_TRANSACTION_MODES",
+    "createTimeoutError"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map