@fireproof/core 0.7.0-alpha.2 → 0.7.0-alpha.4

package/dist/src/fireproof.js

@@ -1,6 +1,5 @@
 'use strict';
 
-var promises = require('fs/promises');
 var http = require('node:http');
 var https = require('node:https');
 var zlib = require('node:zlib');
@@ -11486,15 +11485,7 @@ var _polyfillNode_events = /*#__PURE__*/Object.freeze({
 
 var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_events);
 
-var streamBrowser;
-var hasRequiredStreamBrowser;
-
-function requireStreamBrowser () {
-	if (hasRequiredStreamBrowser) return streamBrowser;
-	hasRequiredStreamBrowser = 1;
-	streamBrowser = require$$0$1.EventEmitter;
-	return streamBrowser;
-}
+var streamBrowser = require$$0$1.EventEmitter;
 
 // shim for using process in browser
 // based off https://github.com/defunctzombie/node-process/blob/master/browser.js
@@ -11637,7 +11628,7 @@ var argv = [];
 var version$2 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
-var config = {};
+var config$1 = {};
 
 function noop$3() {}
 
@@ -11714,7 +11705,7 @@ var browser$1$1 = {
   hrtime: hrtime,
   platform: platform,
   release: release,
-  config: config,
+  config: config$1,
   uptime: uptime
 };
 
@@ -11795,11 +11786,11 @@ function format(f) {
 // Mark that a method should not be used.
 // Returns a modified function which warns once by default.
 // If --no-deprecation is set, then it is a no-op.
-function deprecate$1(fn, msg) {
+function deprecate$2(fn, msg) {
   // Allow for deprecating things in the process of starting up.
   if (isUndefined(global$1.process)) {
     return function() {
-      return deprecate$1(fn, msg).apply(this, arguments);
+      return deprecate$2(fn, msg).apply(this, arguments);
     };
   }
 
@@ -12408,7 +12399,7 @@ var _polyfillNode_util = {
   isBoolean: isBoolean,
   isArray: isArray,
   inspect: inspect,
-  deprecate: deprecate$1,
+  deprecate: deprecate$2,
   format: format,
   debuglog: debuglog,
   promisify: promisify,
@@ -12421,7 +12412,7 @@ var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
   callbackify: callbackify,
   debuglog: debuglog,
   default: _polyfillNode_util,
-  deprecate: deprecate$1,
+  deprecate: deprecate$2,
   format: format,
   inherits: inherits$w,
   inspect: inspect,
@@ -12609,108 +12600,99 @@ function requireBuffer_list () {
 	return buffer_list;
 }
 
-var destroy_1;
-var hasRequiredDestroy;
-
-function requireDestroy () {
-	if (hasRequiredDestroy) return destroy_1;
-	hasRequiredDestroy = 1;
-
-	// undocumented cb() API, needed for core, not for public API
-	function destroy(err, cb) {
-	  const readableDestroyed = this._readableState && this._readableState.destroyed;
-	  const writableDestroyed = this._writableState && this._writableState.destroyed;
-	  if (readableDestroyed || writableDestroyed) {
-	    if (cb) {
-	      cb(err);
-	    } else if (err) {
-	      if (!this._writableState) {
-	        process.nextTick(emitErrorNT, this, err);
-	      } else if (!this._writableState.errorEmitted) {
-	        this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorNT, this, err);
-	      }
-	    }
-	    return this;
-	  }
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+  const readableDestroyed = this._readableState && this._readableState.destroyed;
+  const writableDestroyed = this._writableState && this._writableState.destroyed;
+  if (readableDestroyed || writableDestroyed) {
+    if (cb) {
+      cb(err);
+    } else if (err) {
+      if (!this._writableState) {
+        process.nextTick(emitErrorNT, this, err);
+      } else if (!this._writableState.errorEmitted) {
+        this._writableState.errorEmitted = true;
+        process.nextTick(emitErrorNT, this, err);
+      }
+    }
+    return this;
+  }
 
-	  // we set destroyed to true before firing error callbacks in order
-	  // to make it re-entrance safe in case destroy() is called within callbacks
+  // we set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
 
-	  if (this._readableState) {
-	    this._readableState.destroyed = true;
-	  }
+  if (this._readableState) {
+    this._readableState.destroyed = true;
+  }
 
-	  // if this is a duplex stream mark the writable part as destroyed as well
-	  if (this._writableState) {
-	    this._writableState.destroyed = true;
-	  }
-	  this._destroy(err || null, err => {
-	    if (!cb && err) {
-	      if (!this._writableState) {
-	        process.nextTick(emitErrorAndCloseNT, this, err);
-	      } else if (!this._writableState.errorEmitted) {
-	        this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorAndCloseNT, this, err);
-	      } else {
-	        process.nextTick(emitCloseNT, this);
-	      }
-	    } else if (cb) {
-	      process.nextTick(emitCloseNT, this);
-	      cb(err);
-	    } else {
-	      process.nextTick(emitCloseNT, this);
-	    }
-	  });
-	  return this;
-	}
-	function emitErrorAndCloseNT(self, err) {
-	  emitErrorNT(self, err);
-	  emitCloseNT(self);
-	}
-	function emitCloseNT(self) {
-	  if (self._writableState && !self._writableState.emitClose) return;
-	  if (self._readableState && !self._readableState.emitClose) return;
-	  self.emit('close');
-	}
-	function undestroy() {
-	  if (this._readableState) {
-	    this._readableState.destroyed = false;
-	    this._readableState.reading = false;
-	    this._readableState.ended = false;
-	    this._readableState.endEmitted = false;
-	  }
-	  if (this._writableState) {
-	    this._writableState.destroyed = false;
-	    this._writableState.ended = false;
-	    this._writableState.ending = false;
-	    this._writableState.finalCalled = false;
-	    this._writableState.prefinished = false;
-	    this._writableState.finished = false;
-	    this._writableState.errorEmitted = false;
-	  }
-	}
-	function emitErrorNT(self, err) {
-	  self.emit('error', err);
-	}
-	function errorOrDestroy(stream, err) {
-	  // We have tests that rely on errors being emitted
-	  // in the same tick, so changing this is semver major.
-	  // For now when you opt-in to autoDestroy we allow
-	  // the error to be emitted nextTick. In a future
-	  // semver major update we should change the default to this.
-
-	  const rState = stream._readableState;
-	  const wState = stream._writableState;
-	  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
-	}
-	destroy_1 = {
-	  destroy,
-	  undestroy,
-	  errorOrDestroy
-	};
-	return destroy_1;
+  // if this is a duplex stream mark the writable part as destroyed as well
+  if (this._writableState) {
+    this._writableState.destroyed = true;
+  }
+  this._destroy(err || null, err => {
+    if (!cb && err) {
+      if (!this._writableState) {
+        process.nextTick(emitErrorAndCloseNT, this, err);
+      } else if (!this._writableState.errorEmitted) {
+        this._writableState.errorEmitted = true;
+        process.nextTick(emitErrorAndCloseNT, this, err);
+      } else {
+        process.nextTick(emitCloseNT, this);
+      }
+    } else if (cb) {
+      process.nextTick(emitCloseNT, this);
+      cb(err);
+    } else {
+      process.nextTick(emitCloseNT, this);
+    }
+  });
+  return this;
+}
+function emitErrorAndCloseNT(self, err) {
+  emitErrorNT(self, err);
+  emitCloseNT(self);
+}
+function emitCloseNT(self) {
+  if (self._writableState && !self._writableState.emitClose) return;
+  if (self._readableState && !self._readableState.emitClose) return;
+  self.emit('close');
+}
+function undestroy() {
+  if (this._readableState) {
+    this._readableState.destroyed = false;
+    this._readableState.reading = false;
+    this._readableState.ended = false;
+    this._readableState.endEmitted = false;
+  }
+  if (this._writableState) {
+    this._writableState.destroyed = false;
+    this._writableState.ended = false;
+    this._writableState.ending = false;
+    this._writableState.finalCalled = false;
+    this._writableState.prefinished = false;
+    this._writableState.finished = false;
+    this._writableState.errorEmitted = false;
+  }
+}
+function emitErrorNT(self, err) {
+  self.emit('error', err);
 }
+function errorOrDestroy(stream, err) {
+  // We have tests that rely on errors being emitted
+  // in the same tick, so changing this is semver major.
+  // For now when you opt-in to autoDestroy we allow
+  // the error to be emitted nextTick. In a future
+  // semver major update we should change the default to this.
+
+  const rState = stream._readableState;
+  const wState = stream._writableState;
+  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+}
+var destroy_1 = {
+  destroy,
+  undestroy,
+  errorOrDestroy
+};
 
 var errorsBrowser = {};
 
@@ -12840,109 +12822,92 @@ createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
 createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
 errorsBrowser.codes = codes;
 
-var state;
-var hasRequiredState;
-
-function requireState () {
-	if (hasRequiredState) return state;
-	hasRequiredState = 1;
-
-	const ERR_INVALID_OPT_VALUE = errorsBrowser.codes.ERR_INVALID_OPT_VALUE;
-	function highWaterMarkFrom(options, isDuplex, duplexKey) {
-	  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
-	}
-	function getHighWaterMark(state, options, duplexKey, isDuplex) {
-	  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-	  if (hwm != null) {
-	    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
-	      const name = isDuplex ? duplexKey : 'highWaterMark';
-	      throw new ERR_INVALID_OPT_VALUE(name, hwm);
-	    }
-	    return Math.floor(hwm);
-	  }
-
-	  // Default value
-	  return state.objectMode ? 16 : 16 * 1024;
-	}
-	state = {
-	  getHighWaterMark
-	};
-	return state;
+const ERR_INVALID_OPT_VALUE = errorsBrowser.codes.ERR_INVALID_OPT_VALUE;
+function highWaterMarkFrom(options, isDuplex, duplexKey) {
+  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
 }
+function getHighWaterMark(state, options, duplexKey, isDuplex) {
+  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+  if (hwm != null) {
+    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+      const name = isDuplex ? duplexKey : 'highWaterMark';
+      throw new ERR_INVALID_OPT_VALUE(name, hwm);
+    }
+    return Math.floor(hwm);
+  }
 
-var browser$b;
-var hasRequiredBrowser$3;
+  // Default value
+  return state.objectMode ? 16 : 16 * 1024;
+}
+var state = {
+  getHighWaterMark
+};
 
-function requireBrowser$3 () {
-	if (hasRequiredBrowser$3) return browser$b;
-	hasRequiredBrowser$3 = 1;
-	/**
-	 * Module exports.
-	 */
+/**
+ * Module exports.
+ */
 
-	browser$b = deprecate;
+var browser$b = deprecate$1;
 
-	/**
-	 * Mark that a method should not be used.
-	 * Returns a modified function which warns once by default.
-	 *
-	 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
-	 *
-	 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
-	 * will throw an Error when invoked.
-	 *
-	 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
-	 * will invoke `console.trace()` instead of `console.error()`.
-	 *
-	 * @param {Function} fn - the function to deprecate
-	 * @param {String} msg - the string to print to the console when `fn` is invoked
-	 * @returns {Function} a new "deprecated" version of `fn`
-	 * @api public
-	 */
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
 
-	function deprecate (fn, msg) {
-	  if (config('noDeprecation')) {
-	    return fn;
-	  }
+function deprecate$1 (fn, msg) {
+  if (config('noDeprecation')) {
+    return fn;
+  }
 
-	  var warned = false;
-	  function deprecated() {
-	    if (!warned) {
-	      if (config('throwDeprecation')) {
-	        throw new Error(msg);
-	      } else if (config('traceDeprecation')) {
-	        console.trace(msg);
-	      } else {
-	        console.warn(msg);
-	      }
-	      warned = true;
-	    }
-	    return fn.apply(this, arguments);
-	  }
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config('throwDeprecation')) {
+        throw new Error(msg);
+      } else if (config('traceDeprecation')) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
 
-	  return deprecated;
-	}
+  return deprecated;
+}
 
-	/**
-	 * Checks `localStorage` for boolean values for the given `name`.
-	 *
-	 * @param {String} name
-	 * @returns {Boolean}
-	 * @api private
-	 */
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
 
-	function config (name) {
-	  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
-	  try {
-	    if (!commonjsGlobal.localStorage) return false;
-	  } catch (_) {
-	    return false;
-	  }
-	  var val = commonjsGlobal.localStorage[name];
-	  if (null == val) return false;
-	  return String(val).toLowerCase() === 'true';
-	}
-	return browser$b;
+function config (name) {
+  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+  try {
+    if (!commonjsGlobal.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = commonjsGlobal.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === 'true';
 }
 
 var _stream_writable;
@@ -12973,12 +12938,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	const internalUtil = {
-	  deprecate: requireBrowser$3()
+	  deprecate: browser$b
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -12989,8 +12954,8 @@ function require_stream_writable () {
 	function _isUint8Array(obj) {
 	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
-	const destroyImpl = requireDestroy();
-	const _require = requireState(),
+	const destroyImpl = destroy_1;
+	const _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -14184,7 +14149,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -14207,8 +14172,8 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	const BufferList = requireBuffer_list();
-	const destroyImpl = requireDestroy();
-	const _require = requireState(),
+	const destroyImpl = destroy_1;
+	const _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -17574,7 +17539,7 @@ function WriteReq(chunk, encoding, cb) {
 
 function WritableState(options, stream) {
   Object.defineProperty(this, 'buffer', {
-    get: deprecate$1(function () {
+    get: deprecate$2(function () {
       return this.getBuffer();
     }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
   });
@@ -39250,9 +39215,9 @@ function loadSync (filename) {
 }
 
 async function writeSync (fullpath, stringValue) {
-  await promises.mkdir(dirname(fullpath), { recursive: true });
+  await fs.promises.mkdir(dirname(fullpath), { recursive: true });
   // writeFileSync(fullpath, stringValue)
-  await promises.writeFile(fullpath, stringValue);
+  await fs.promises.writeFile(fullpath, stringValue);
 }
 
 /**