@fireproof/core 0.7.2-dev.6 → 0.7.2-dev.7

package/dist/src/fireproof.mjs

@@ -8198,7 +8198,15 @@ var _polyfillNode_events = /*#__PURE__*/Object.freeze({
 
 var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_events);
 
-var streamBrowser = require$$0$1.EventEmitter;
+var streamBrowser;
+var hasRequiredStreamBrowser;
+
+function requireStreamBrowser () {
+	if (hasRequiredStreamBrowser) return streamBrowser;
+	hasRequiredStreamBrowser = 1;
+	streamBrowser = require$$0$1.EventEmitter;
+	return streamBrowser;
+}
 
 // shim for using process in browser
 // based off https://github.com/defunctzombie/node-process/blob/master/browser.js
@@ -8341,7 +8349,7 @@ var argv = [];
 var version$1 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
-var config$1 = {};
+var config = {};
 
 function noop$3() {}
 
@@ -8418,7 +8426,7 @@ var browser$1$1 = {
   hrtime: hrtime,
   platform: platform,
   release: release,
-  config: config$1,
+  config: config,
   uptime: uptime
 };
 
@@ -8499,11 +8507,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(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(fn, msg).apply(this, arguments);
     };
   }
 
@@ -9112,7 +9120,7 @@ var _polyfillNode_util = {
   isBoolean: isBoolean,
   isArray: isArray,
   inspect: inspect,
-  deprecate: deprecate$1,
+  deprecate: deprecate,
   format: format,
   debuglog: debuglog,
   promisify: promisify,
@@ -9125,7 +9133,7 @@ var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
   callbackify: callbackify,
   debuglog: debuglog,
   default: _polyfillNode_util,
-  deprecate: deprecate$1,
+  deprecate: deprecate,
   format: format,
   inherits: inherits$1,
   inspect: inspect,
@@ -9313,99 +9321,108 @@ function requireBuffer_list () {
 	return buffer_list;
 }
 
-// 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;
-  }
+var destroy_1;
+var hasRequiredDestroy;
 
-  // we set destroyed to true before firing error callbacks in order
-  // to make it re-entrance safe in case destroy() is called within callbacks
+function requireDestroy () {
+	if (hasRequiredDestroy) return destroy_1;
+	hasRequiredDestroy = 1;
 
-  if (this._readableState) {
-    this._readableState.destroyed = true;
-  }
+	// 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;
+	  }
 
-  // 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.
+	  // we set destroyed to true before firing error callbacks in order
+	  // to make it re-entrance safe in case destroy() is called within callbacks
 
-  const rState = stream._readableState;
-  const wState = stream._writableState;
-  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+	  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;
 }
-var destroy_1 = {
-  destroy,
-  undestroy,
-  errorOrDestroy
-};
 
 var errorsBrowser = {};
 
@@ -9535,92 +9552,109 @@ createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
 createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
 errorsBrowser.codes = codes;
 
-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 state;
+var hasRequiredState;
+
+function requireState () {
+	if (hasRequiredState) return state;
+	hasRequiredState = 1;
 
-  // Default value
-  return state.objectMode ? 16 : 16 * 1024;
+	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;
 }
-var state = {
-  getHighWaterMark
-};
 
-/**
- * Module exports.
- */
+var browser$b;
+var hasRequiredBrowser$a;
 
-var browser$b = deprecate;
+function requireBrowser$a () {
+	if (hasRequiredBrowser$a) return browser$b;
+	hasRequiredBrowser$a = 1;
+	/**
+	 * Module exports.
+	 */
 
-/**
- * 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
- */
+	browser$b = deprecate;
 
-function deprecate (fn, msg) {
-  if (config('noDeprecation')) {
-    return fn;
-  }
+	/**
+	 * 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
+	 */
 
-  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);
-  }
+	function deprecate (fn, msg) {
+	  if (config('noDeprecation')) {
+	    return fn;
+	  }
 
-  return deprecated;
-}
+	  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);
+	  }
 
-/**
- * Checks `localStorage` for boolean values for the given `name`.
- *
- * @param {String} name
- * @returns {Boolean}
- * @api private
- */
+	  return deprecated;
+	}
 
-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';
+	/**
+	 * 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;
 }
 
 var _stream_writable;
@@ -9651,12 +9685,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	const internalUtil = {
-	  deprecate: browser$b
+	  deprecate: requireBrowser$a()
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = streamBrowser;
+	var Stream = requireStreamBrowser();
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -9667,8 +9701,8 @@ function require_stream_writable () {
 	function _isUint8Array(obj) {
 	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
-	const destroyImpl = destroy_1;
-	const _require = state,
+	const destroyImpl = requireDestroy();
+	const _require = requireState(),
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -10862,7 +10896,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = streamBrowser;
+	var Stream = requireStreamBrowser();
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -10885,8 +10919,8 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	const BufferList = requireBuffer_list();
-	const destroyImpl = destroy_1;
-	const _require = state,
+	const destroyImpl = requireDestroy();
+	const _require = requireState(),
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -14339,7 +14373,7 @@ function WriteReq(chunk, encoding, cb) {
 
 function WritableState(options, stream) {
   Object.defineProperty(this, 'buffer', {
-    get: deprecate$1(function () {
+    get: deprecate(function () {
       return this.getBuffer();
     }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
   });
@@ -38906,6 +38940,7 @@ class Base {
       lastCid: clock[0],
       get: cid => allBlocks.get(cid.toString())
     };
+    console.log('compact', this.instanceId, this.name, blocks.lastCid.toString(), dataCids.length);
     await this.parkCar(blocks, dataCids);
   }
 
@@ -39050,6 +39085,7 @@ class Base {
 
   async mapForIPLDHashmapCarCid (carCid) {
     // console.log('mapForIPLDHashmapCarCid', carCid)
+    // todo why is this writeable?
     const carMapReader = await this.getWriteableCarReader(carCid);
     const indexNode = await load$1(carMapReader, carMapReader.root.cid, {
       blockHasher: blockOpts$1.hasher,
@@ -39088,7 +39124,21 @@ class Base {
     return combinedReader
   }
 
+  async xgetCarReader (carCid) {
+    return this.getCarReaderImpl(carCid)
+  }
+
+  carReaderCache = new Map()
   async getCarReader (carCid) {
+    if (this.carReaderCache.has(carCid)) {
+      return this.carReaderCache.get(carCid)
+    }
+    const result = await this.getCarReaderImpl(carCid);
+    this.carReaderCache.set(carCid, result);
+    return result
+  }
+
+  async getCarReaderImpl (carCid) {
     carCid = carCid.toString();
     const carBytes = await this.readCar(carCid);
     // console.log('getCarReader', this.constructor.name, carCid, carBytes.length)
@@ -40079,19 +40129,6 @@ class Valet {
     }
   }
 
-  // async compact() {
-  //   const carCids = []
-  //   // for await (const { cid } of this.valet.cids()) {
-  //   //   yield { cid }
-  //   // }
-  //   // create a blockstore with all data
-  //   {
-  //     entries: () => syncCIDs.map(cid => ({ cid })),
-  //     get: async cid => await blocks.get(cid)
-  //   }
-  //   // park it
-  // }
-
   /**
    * Iterate over all blocks in the store.
    *