@converse/skeletor 3.0.1 → 3.1.0

package/dist/skeletor.js

@@ -5,7 +5,7 @@
 })(this, (function (exports) { 'use strict';
 
   /** Used for built-in method references. */
-  var objectProto$l = Object.prototype;
+  var objectProto$m = Object.prototype;
 
   /**
    * Checks if `value` is likely a prototype object.
@@ -16,7 +16,7 @@
    */
   function isPrototype(value) {
     var Ctor = value && value.constructor,
-        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$l;
+        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$m;
 
     return value === proto;
   }
@@ -39,10 +39,10 @@
   var nativeKeys = overArg(Object.keys, Object);
 
   /** Used for built-in method references. */
-  var objectProto$k = Object.prototype;
+  var objectProto$l = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$h = objectProto$k.hasOwnProperty;
+  var hasOwnProperty$i = objectProto$l.hasOwnProperty;
 
   /**
    * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
@@ -57,7 +57,7 @@
     }
     var result = [];
     for (var key in Object(object)) {
-      if (hasOwnProperty$h.call(object, key) && key != 'constructor') {
+      if (hasOwnProperty$i.call(object, key) && key != 'constructor') {
         result.push(key);
       }
     }
@@ -77,17 +77,17 @@
   var Symbol$1 = root$1.Symbol;
 
   /** Used for built-in method references. */
-  var objectProto$j = Object.prototype;
+  var objectProto$k = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$g = objectProto$j.hasOwnProperty;
+  var hasOwnProperty$h = objectProto$k.hasOwnProperty;
 
   /**
    * Used to resolve the
    * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
    * of values.
    */
-  var nativeObjectToString$2 = objectProto$j.toString;
+  var nativeObjectToString$2 = objectProto$k.toString;
 
   /** Built-in value references. */
   var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : undefined;
@@ -100,7 +100,7 @@
    * @returns {string} Returns the raw `toStringTag`.
    */
   function getRawTag(value) {
-    var isOwn = hasOwnProperty$g.call(value, symToStringTag$1),
+    var isOwn = hasOwnProperty$h.call(value, symToStringTag$1),
         tag = value[symToStringTag$1];
 
     try {
@@ -120,14 +120,14 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$i = Object.prototype;
+  var objectProto$j = Object.prototype;
 
   /**
    * Used to resolve the
    * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
    * of values.
    */
-  var nativeObjectToString$1 = objectProto$i.toString;
+  var nativeObjectToString$1 = objectProto$j.toString;
 
   /**
    * Converts `value` to a string using `Object.prototype.toString`.
@@ -282,17 +282,17 @@
 
   /** Used for built-in method references. */
   var funcProto$1 = Function.prototype,
-      objectProto$h = Object.prototype;
+      objectProto$i = Object.prototype;
 
   /** Used to resolve the decompiled source of functions. */
   var funcToString$1 = funcProto$1.toString;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$f = objectProto$h.hasOwnProperty;
+  var hasOwnProperty$g = objectProto$i.hasOwnProperty;
 
   /** Used to detect if a method is native. */
   var reIsNative = RegExp('^' +
-    funcToString$1.call(hasOwnProperty$f).replace(reRegExpChar, '\\$&')
+    funcToString$1.call(hasOwnProperty$g).replace(reRegExpChar, '\\$&')
     .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
   );
 
@@ -341,16 +341,16 @@
   var DataView = getNative(root$1, 'DataView');
 
   /* Built-in method references that are verified to be native. */
-  var Map = getNative(root$1, 'Map');
+  var Map$1 = getNative(root$1, 'Map');
 
   /* Built-in method references that are verified to be native. */
   var Promise$1 = getNative(root$1, 'Promise');
 
   /* Built-in method references that are verified to be native. */
-  var Set = getNative(root$1, 'Set');
+  var Set$1 = getNative(root$1, 'Set');
 
   /* Built-in method references that are verified to be native. */
-  var WeakMap = getNative(root$1, 'WeakMap');
+  var WeakMap$1 = getNative(root$1, 'WeakMap');
 
   /** `Object#toString` result references. */
   var mapTag$6 = '[object Map]',
@@ -363,10 +363,10 @@
 
   /** Used to detect maps, sets, and weakmaps. */
   var dataViewCtorString = toSource(DataView),
-      mapCtorString = toSource(Map),
+      mapCtorString = toSource(Map$1),
       promiseCtorString = toSource(Promise$1),
-      setCtorString = toSource(Set),
-      weakMapCtorString = toSource(WeakMap);
+      setCtorString = toSource(Set$1),
+      weakMapCtorString = toSource(WeakMap$1);
 
   /**
    * Gets the `toStringTag` of `value`.
@@ -379,10 +379,10 @@
 
   // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
   if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$4) ||
-      (Map && getTag(new Map) != mapTag$6) ||
+      (Map$1 && getTag(new Map$1) != mapTag$6) ||
       (Promise$1 && getTag(Promise$1.resolve()) != promiseTag) ||
-      (Set && getTag(new Set) != setTag$6) ||
-      (WeakMap && getTag(new WeakMap) != weakMapTag$2)) {
+      (Set$1 && getTag(new Set$1) != setTag$6) ||
+      (WeakMap$1 && getTag(new WeakMap$1) != weakMapTag$2)) {
     getTag = function(value) {
       var result = baseGetTag(value),
           Ctor = result == objectTag$4 ? value.constructor : undefined,
@@ -444,13 +444,13 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$g = Object.prototype;
+  var objectProto$h = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$e = objectProto$g.hasOwnProperty;
+  var hasOwnProperty$f = objectProto$h.hasOwnProperty;
 
   /** Built-in value references. */
-  var propertyIsEnumerable$1 = objectProto$g.propertyIsEnumerable;
+  var propertyIsEnumerable$1 = objectProto$h.propertyIsEnumerable;
 
   /**
    * Checks if `value` is likely an `arguments` object.
@@ -471,7 +471,7 @@
    * // => false
    */
   var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
-    return isObjectLike(value) && hasOwnProperty$e.call(value, 'callee') &&
+    return isObjectLike(value) && hasOwnProperty$f.call(value, 'callee') &&
       !propertyIsEnumerable$1.call(value, 'callee');
   };
 
@@ -736,10 +736,10 @@
       setTag$4 = '[object Set]';
 
   /** Used for built-in method references. */
-  var objectProto$f = Object.prototype;
+  var objectProto$g = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$d = objectProto$f.hasOwnProperty;
+  var hasOwnProperty$e = objectProto$g.hasOwnProperty;
 
   /**
    * Checks if `value` is an empty object, collection, map, or set.
@@ -791,7 +791,7 @@
       return !baseKeys(value).length;
     }
     for (var key in value) {
-      if (hasOwnProperty$d.call(value, key)) {
+      if (hasOwnProperty$e.call(value, key)) {
         return false;
       }
     }
@@ -842,10 +842,10 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$e = Object.prototype;
+  var objectProto$f = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$c = objectProto$e.hasOwnProperty;
+  var hasOwnProperty$d = objectProto$f.hasOwnProperty;
 
   /**
    * Creates an array of the enumerable property names of the array-like `value`.
@@ -865,7 +865,7 @@
         length = result.length;
 
     for (var key in value) {
-      if ((inherited || hasOwnProperty$c.call(value, key)) &&
+      if ((inherited || hasOwnProperty$d.call(value, key)) &&
           !(skipIndexes && (
              // Safari 9 has enumerable `arguments.length` in strict mode.
              key == 'length' ||
@@ -1008,7 +1008,7 @@
    * _.toString([1, 2, 3]);
    * // => '1,2,3'
    */
-  function toString$2(value) {
+  function toString$1(value) {
     return value == null ? '' : baseToString(value);
   }
 
@@ -1034,7 +1034,7 @@
    */
   function uniqueId(prefix) {
     var id = ++idCounter;
-    return toString$2(prefix) + id;
+    return toString$1(prefix) + id;
   }
 
   /** Used to match a single whitespace character. */
@@ -1630,6 +1630,14 @@
               eventsApi(triggerApi, this._events, name, undefined, args);
               return this;
           }
+          /**
+           * Subscribe to an event. Returns an unsubscribe function.
+           * Compatible with `useSyncExternalStore` and other store-style APIs.
+           */
+          subscribe(event, callback, context) {
+              this.on(event, callback, context);
+              return () => this.off(event, callback, context);
+          }
       };
   }
   /**
@@ -1637,7 +1645,7 @@
    */
   const EventEmitterObject = EventEmitter(Object);
 
-  /*! *****************************************************************************
+  /******************************************************************************
   Copyright (c) Microsoft Corporation.
 
   Permission to use, copy, modify, and/or distribute this software for any
@@ -1651,7 +1659,7 @@
   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
   PERFORMANCE OF THIS SOFTWARE.
   ***************************************************************************** */
-  /* global Reflect, Promise */
+  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
   function __values(o) {
@@ -1664,7 +1672,25 @@
           }
       };
       throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-  }
+  }
+
+  function __classPrivateFieldGet(receiver, state, kind, f) {
+      if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+      return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+  }
+
+  function __classPrivateFieldSet(receiver, state, value, kind, f) {
+      if (kind === "m") throw new TypeError("Private method is not writable");
+      if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+      return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+  }
+
+  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
 
   /*!
   MIT License
@@ -1703,7 +1729,7 @@
    * @param parts
    * @param properties
    */
-  function createBlob$1(parts, properties) {
+  function createBlob(parts, properties) {
       /* global BlobBuilder,MSBlobBuilder,MozBlobBuilder,WebKitBlobBuilder */
       parts = parts || [];
       properties = properties || {};
@@ -1727,12 +1753,12 @@
       }
   }
 
-  var BLOB_TYPE_PREFIX_REGEX$1 = /^~~local_forage_type~([^~]+)~/;
-  var SERIALIZED_MARKER_LENGTH$1 = "__lfsc__:" /* SERIALIZED_MARKER */.length;
-  var TYPE_SERIALIZED_MARKER_LENGTH$1 = SERIALIZED_MARKER_LENGTH$1 + "arbf" /* TYPE_ARRAYBUFFER */.length;
+  var BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/;
+  var SERIALIZED_MARKER_LENGTH = "__lfsc__:" /* SERIALIZED_MARKER */.length;
+  var TYPE_SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER_LENGTH + "arbf" /* TYPE_ARRAYBUFFER */.length;
   //tslint:disable:no-magic-numbers no-bitwise prefer-switch no-unbound-method
-  var toString$1 = Object.prototype.toString;
-  function stringToBuffer$1(serializedString) {
+  var toString = Object.prototype.toString;
+  function stringToBuffer(serializedString) {
       // Fill the string into a ArrayBuffer.
       var bufferLength = serializedString.length * 0.75;
       var len = serializedString.length;
@@ -1759,7 +1785,7 @@
    * Converts a buffer to a string to store, serialized, in the backend
    * storage library.
    */
-  function bufferToString$1(buffer) {
+  function bufferToString(buffer) {
       // base64-arraybuffer
       var bytes = new Uint8Array(buffer);
       var base64String = '';
@@ -1786,15 +1812,15 @@
    * @param value
    * @param callback
    */
-  function serialize$2(value, callback) {
+  function serialize$1(value, callback) {
       var valueType = '';
       if (value) {
-          valueType = toString$1.call(value);
+          valueType = toString.call(value);
       }
       // Cannot use `value instanceof ArrayBuffer` or such here, as these
       // checks fail when running the tests using casper.js...
       if (value && (valueType === '[object ArrayBuffer]' ||
-          (value.buffer && toString$1.call(value.buffer) === '[object ArrayBuffer]'))) {
+          (value.buffer && toString.call(value.buffer) === '[object ArrayBuffer]'))) {
           // Convert binary arrays to a string and prefix the string with
           // a special marker.
           var buffer = void 0;
@@ -1836,7 +1862,7 @@
                   callback(new Error('Failed to get type for BinaryArray'));
               }
           }
-          callback(marker + bufferToString$1(buffer));
+          callback(marker + bufferToString(buffer));
       }
       else if (valueType === '[object Blob]') {
           // Convert the blob to a binaryArray and then to a string.
@@ -1844,7 +1870,7 @@
           fileReader.onload = function () {
               // Backwards-compatible prefix for the blob type.
               //tslint:disable-next-line:restrict-plus-operands
-              var str = "~~local_forage_type~" /* BLOB_TYPE_PREFIX */ + value.type + "~" + bufferToString$1(this.result);
+              var str = "~~local_forage_type~" /* BLOB_TYPE_PREFIX */ + value.type + "~" + bufferToString(this.result);
               callback("__lfsc__:" /* SERIALIZED_MARKER */ + "blob" /* TYPE_BLOB */ + str);
           };
           fileReader.readAsArrayBuffer(value);
@@ -1870,34 +1896,34 @@
    * some kind of arraybuffer/binary data/typed array out of the string.
    * @param value
    */
-  function deserialize$2(value) {
+  function deserialize$1(value) {
       // If we haven't marked this string as being specially serialized (i.e.
       // something other than serialized JSON), we can just return it and be
       // done with it.
-      if (value.substring(0, SERIALIZED_MARKER_LENGTH$1) !== "__lfsc__:" /* SERIALIZED_MARKER */) {
+      if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== "__lfsc__:" /* SERIALIZED_MARKER */) {
           return JSON.parse(value);
       }
       // The following code deals with deserializing some kind of Blob or
       // TypedArray. First we separate out the type of data we're dealing
       // with from the data itself.
-      var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH$1);
-      var type = value.substring(SERIALIZED_MARKER_LENGTH$1, TYPE_SERIALIZED_MARKER_LENGTH$1);
+      var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH);
+      var type = value.substring(SERIALIZED_MARKER_LENGTH, TYPE_SERIALIZED_MARKER_LENGTH);
       var blobType;
       // Backwards-compatible blob type serialization strategy.
       // DBs created with older versions of localForage will simply not have the blob type.
-      if (type === "blob" /* TYPE_BLOB */ && BLOB_TYPE_PREFIX_REGEX$1.test(serializedString)) {
-          var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX$1);
+      if (type === "blob" /* TYPE_BLOB */ && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) {
+          var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX);
           blobType = matcher[1];
           serializedString = serializedString.substring(matcher[0].length);
       }
-      var buffer = stringToBuffer$1(serializedString);
+      var buffer = stringToBuffer(serializedString);
       // Return the right type based on the code/type set during
       // serialization.
       switch (type) {
           case "arbf" /* TYPE_ARRAYBUFFER */:
               return buffer;
           case "blob" /* TYPE_BLOB */:
-              return createBlob$1([buffer], { type: blobType });
+              return createBlob([buffer], { type: blobType });
           case "si08" /* TYPE_INT8ARRAY */:
               return new Int8Array(buffer);
           case "ui08" /* TYPE_UINT8ARRAY */:
@@ -1951,7 +1977,7 @@
       return (options.name || defaultConfig.name) + "/" + (options.storeName || defaultConfig.storeName) + "/";
   }
 
-  function executeCallback$2(promise, callback) {
+  function executeCallback$1(promise, callback) {
       if (callback) {
           promise.then(function (result) {
               callback(null, result);
@@ -2004,10 +2030,10 @@
   }
 
   var serialiser = {
-      bufferToString: bufferToString$1,
-      deserialize: deserialize$2,
-      serialize: serialize$2,
-      stringToBuffer: stringToBuffer$1
+      bufferToString: bufferToString,
+      deserialize: deserialize$1,
+      serialize: serialize$1,
+      stringToBuffer: stringToBuffer
   };
 
   /*!
@@ -2092,7 +2118,7 @@
       var promise = this.ready().then(function () {
           _this._dbInfo.mStore.clear();
       });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
@@ -2101,7 +2127,7 @@
       var outPromise = promise.then(function (keyPrefix) {
           Store.resolve(keyPrefix).drop();
       });
-      executeCallback$2(outPromise, callback);
+      executeCallback$1(outPromise, callback);
       return promise;
   }
 
@@ -2113,7 +2139,7 @@
           // Deserialise if the result is not null or undefined
           return result == null ? null : _this._dbInfo.serializer.deserialize(result); //tslint:disable-line:triple-equals
       });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
@@ -2137,7 +2163,7 @@
               }
           }
       });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
@@ -2156,7 +2182,7 @@
           }
           return result;
       });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
@@ -2165,13 +2191,13 @@
       var promise = this.ready().then(function () {
           return _this._dbInfo.mStore.keys();
       });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
   function length$1(callback) {
       var promise = this.keys().then(function (keys$) { return keys$.length; });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
@@ -2181,7 +2207,7 @@
       var promise = this.ready().then(function () {
           _this._dbInfo.mStore.rm(key$);
       });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
@@ -2211,7 +2237,7 @@
               });
           });
       });
-      executeCallback$2(promise, callback);
+      executeCallback$1(promise, callback);
       return promise;
   }
 
@@ -2498,10 +2524,10 @@
   var HASH_UNDEFINED$2 = '__lodash_hash_undefined__';
 
   /** Used for built-in method references. */
-  var objectProto$d = Object.prototype;
+  var objectProto$e = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$b = objectProto$d.hasOwnProperty;
+  var hasOwnProperty$c = objectProto$e.hasOwnProperty;
 
   /**
    * Gets the hash value for `key`.
@@ -2518,14 +2544,14 @@
       var result = data[key];
       return result === HASH_UNDEFINED$2 ? undefined : result;
     }
-    return hasOwnProperty$b.call(data, key) ? data[key] : undefined;
+    return hasOwnProperty$c.call(data, key) ? data[key] : undefined;
   }
 
   /** Used for built-in method references. */
-  var objectProto$c = Object.prototype;
+  var objectProto$d = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$a = objectProto$c.hasOwnProperty;
+  var hasOwnProperty$b = objectProto$d.hasOwnProperty;
 
   /**
    * Checks if a hash value for `key` exists.
@@ -2538,7 +2564,7 @@
    */
   function hashHas(key) {
     var data = this.__data__;
-    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty$a.call(data, key);
+    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty$b.call(data, key);
   }
 
   /** Used to stand-in for `undefined` hash values. */
@@ -2597,7 +2623,7 @@
     this.size = 0;
     this.__data__ = {
       'hash': new Hash,
-      'map': new (Map || ListCache),
+      'map': new (Map$1 || ListCache),
       'string': new Hash
     };
   }
@@ -2733,7 +2759,7 @@
     var data = this.__data__;
     if (data instanceof ListCache) {
       var pairs = data.__data__;
-      if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+      if (!Map$1 || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
         pairs.push([key, value]);
         this.size = ++data.size;
         return this;
@@ -2816,10 +2842,10 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$b = Object.prototype;
+  var objectProto$c = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+  var hasOwnProperty$a = objectProto$c.hasOwnProperty;
 
   /**
    * Assigns `value` to `key` of `object` if the existing value is not equivalent
@@ -2833,7 +2859,7 @@
    */
   function assignValue(object, key, value) {
     var objValue = object[key];
-    if (!(hasOwnProperty$9.call(object, key) && eq(objValue, value)) ||
+    if (!(hasOwnProperty$a.call(object, key) && eq(objValue, value)) ||
         (value === undefined && !(key in object))) {
       baseAssignValue(object, key, value);
     }
@@ -2906,10 +2932,10 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$a = Object.prototype;
+  var objectProto$b = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
+  var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
 
   /**
    * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
@@ -2926,7 +2952,7 @@
         result = [];
 
     for (var key in object) {
-      if (!(key == 'constructor' && (isProto || !hasOwnProperty$8.call(object, key)))) {
+      if (!(key == 'constructor' && (isProto || !hasOwnProperty$9.call(object, key)))) {
         result.push(key);
       }
     }
@@ -3071,10 +3097,10 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$9 = Object.prototype;
+  var objectProto$a = Object.prototype;
 
   /** Built-in value references. */
-  var propertyIsEnumerable = objectProto$9.propertyIsEnumerable;
+  var propertyIsEnumerable = objectProto$a.propertyIsEnumerable;
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
@@ -3201,10 +3227,10 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$8 = Object.prototype;
+  var objectProto$9 = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+  var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
 
   /**
    * Initializes an array clone.
@@ -3218,7 +3244,7 @@
         result = new array.constructor(length);
 
     // Add properties assigned by `RegExp#exec`.
-    if (length && typeof array[0] == 'string' && hasOwnProperty$7.call(array, 'index')) {
+    if (length && typeof array[0] == 'string' && hasOwnProperty$8.call(array, 'index')) {
       result.index = array.index;
       result.input = array.input;
     }
@@ -6598,13 +6624,13 @@
 
   /** Used for built-in method references. */
   var funcProto = Function.prototype,
-      objectProto$7 = Object.prototype;
+      objectProto$8 = Object.prototype;
 
   /** Used to resolve the decompiled source of functions. */
   var funcToString = funcProto.toString;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+  var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
 
   /** Used to infer the `Object` constructor. */
   var objectCtorString = funcToString.call(Object);
@@ -6645,7 +6671,7 @@
     if (proto === null) {
       return true;
     }
-    var Ctor = hasOwnProperty$6.call(proto, 'constructor') && proto.constructor;
+    var Ctor = hasOwnProperty$7.call(proto, 'constructor') && proto.constructor;
     return typeof Ctor == 'function' && Ctor instanceof Ctor &&
       funcToString.call(Ctor) == objectCtorString;
   }
@@ -7377,310 +7403,43 @@
     return debounced;
   }
 
-  function executeCallback$1(promise, callback) {
+  function chainCallback(promise, callback) {
       if (callback) {
-          promise.then(
-              function(result) {
-                  callback(null, result);
-              },
-              function(error) {
-                  callback(error);
-              }
-          );
+          promise.then((result) => callback(null, result), (err) => callback(err));
       }
   }
-
-  function getCallback() {
-      if (
-          arguments.length &&
-          typeof arguments[arguments.length - 1] === 'function'
-      ) {
-          return arguments[arguments.length - 1];
+  function getCallback(...args) {
+      if (args.length && typeof args[args.length - 1] === 'function') {
+          return args[args.length - 1];
       }
   }
-
   function normalizeKey(key) {
-      // Cast the key to a string, as that's all we can set as a key.
       if (typeof key !== 'string') {
           console.warn(`${key} used as a key, but it is not a string.`);
           key = String(key);
       }
-
       return key;
   }
-
-  // Abstracts constructing a Blob object, so it also works in older
-  // browsers that don't support the native Blob constructor. (i.e.
-  // old QtWebKit versions, at least).
-  // Abstracts constructing a Blob object, so it also works in older
-  // browsers that don't support the native Blob constructor. (i.e.
-  // old QtWebKit versions, at least).
-  function createBlob(parts, properties) {
-      /* global BlobBuilder,MSBlobBuilder,MozBlobBuilder,WebKitBlobBuilder */
-      parts = parts || [];
-      properties = properties || {};
-      try {
-          return new Blob(parts, properties);
-      } catch (e) {
-          if (e.name !== 'TypeError') {
-              throw e;
-          }
-          var Builder =
-              typeof BlobBuilder !== 'undefined'
-                  ? BlobBuilder
-                  : typeof MSBlobBuilder !== 'undefined'
-                    ? MSBlobBuilder
-                    : typeof MozBlobBuilder !== 'undefined'
-                      ? MozBlobBuilder
-                      : WebKitBlobBuilder;
-          var builder = new Builder();
-          for (var i = 0; i < parts.length; i += 1) {
-              builder.append(parts[i]);
+  function serializeSync(value) {
+      return JSON.stringify(value, (_key, val) => {
+          if (val instanceof Date) {
+              return val.toISOString();
           }
-          return builder.getBlob(properties.type);
-      }
-  }
-
-  /* eslint-disable no-bitwise */
-
-  // Sadly, the best way to save binary data in WebSQL/localStorage is serializing
-  // it to Base64, so this is how we store it to prevent very strange errors with less
-  // verbose ways of binary <-> string data storage.
-  var BASE_CHARS =
-      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-  var BLOB_TYPE_PREFIX = '~~local_forage_type~';
-  var BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/;
-
-  var SERIALIZED_MARKER = '__lfsc__:';
-  var SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER.length;
-
-  // OMG the serializations!
-  var TYPE_ARRAYBUFFER = 'arbf';
-  var TYPE_BLOB = 'blob';
-  var TYPE_INT8ARRAY = 'si08';
-  var TYPE_UINT8ARRAY = 'ui08';
-  var TYPE_UINT8CLAMPEDARRAY = 'uic8';
-  var TYPE_INT16ARRAY = 'si16';
-  var TYPE_INT32ARRAY = 'si32';
-  var TYPE_UINT16ARRAY = 'ur16';
-  var TYPE_UINT32ARRAY = 'ui32';
-  var TYPE_FLOAT32ARRAY = 'fl32';
-  var TYPE_FLOAT64ARRAY = 'fl64';
-  var TYPE_SERIALIZED_MARKER_LENGTH =
-      SERIALIZED_MARKER_LENGTH + TYPE_ARRAYBUFFER.length;
-
-  var toString = Object.prototype.toString;
-
-  function stringToBuffer(serializedString) {
-      // Fill the string into a ArrayBuffer.
-      var bufferLength = serializedString.length * 0.75;
-      var len = serializedString.length;
-      var i;
-      var p = 0;
-      var encoded1, encoded2, encoded3, encoded4;
-
-      if (serializedString[serializedString.length - 1] === '=') {
-          bufferLength--;
-          if (serializedString[serializedString.length - 2] === '=') {
-              bufferLength--;
-          }
-      }
-
-      var buffer = new ArrayBuffer(bufferLength);
-      var bytes = new Uint8Array(buffer);
-
-      for (i = 0; i < len; i += 4) {
-          encoded1 = BASE_CHARS.indexOf(serializedString[i]);
-          encoded2 = BASE_CHARS.indexOf(serializedString[i + 1]);
-          encoded3 = BASE_CHARS.indexOf(serializedString[i + 2]);
-          encoded4 = BASE_CHARS.indexOf(serializedString[i + 3]);
-
-          /*jslint bitwise: true */
-          bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
-          bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
-          bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
-      }
-      return buffer;
+          return val;
+      });
   }
-
-  // Converts a buffer to a string to store, serialized, in the backend
-  // storage library.
-  function bufferToString(buffer) {
-      // base64-arraybuffer
-      var bytes = new Uint8Array(buffer);
-      var base64String = '';
-      var i;
-
-      for (i = 0; i < bytes.length; i += 3) {
-          /*jslint bitwise: true */
-          base64String += BASE_CHARS[bytes[i] >> 2];
-          base64String += BASE_CHARS[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
-          base64String +=
-              BASE_CHARS[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
-          base64String += BASE_CHARS[bytes[i + 2] & 63];
+  function serialize(value, callback) {
+      try {
+          callback(serializeSync(value), null);
       }
-
-      if (bytes.length % 3 === 2) {
-          base64String = base64String.substring(0, base64String.length - 1) + '=';
-      } else if (bytes.length % 3 === 1) {
-          base64String =
-              base64String.substring(0, base64String.length - 2) + '==';
+      catch (e) {
+          callback('', e);
       }
-
-      return base64String;
   }
-
-  // Serialize a value, afterwards executing a callback (which usually
-  // instructs the `setItem()` callback/promise to be executed). This is how
-  // we store binary data with localStorage.
-  function serialize$1(value, callback) {
-      var valueType = '';
-      if (value) {
-          valueType = toString.call(value);
-      }
-
-      // Cannot use `value instanceof ArrayBuffer` or such here, as these
-      // checks fail when running the tests using casper.js...
-      //
-      // TODO: See why those tests fail and use a better solution.
-      if (
-          value &&
-          (valueType === '[object ArrayBuffer]' ||
-              (value.buffer &&
-                  toString.call(value.buffer) === '[object ArrayBuffer]'))
-      ) {
-          // Convert binary arrays to a string and prefix the string with
-          // a special marker.
-          var buffer;
-          var marker = SERIALIZED_MARKER;
-
-          if (value instanceof ArrayBuffer) {
-              buffer = value;
-              marker += TYPE_ARRAYBUFFER;
-          } else {
-              buffer = value.buffer;
-
-              if (valueType === '[object Int8Array]') {
-                  marker += TYPE_INT8ARRAY;
-              } else if (valueType === '[object Uint8Array]') {
-                  marker += TYPE_UINT8ARRAY;
-              } else if (valueType === '[object Uint8ClampedArray]') {
-                  marker += TYPE_UINT8CLAMPEDARRAY;
-              } else if (valueType === '[object Int16Array]') {
-                  marker += TYPE_INT16ARRAY;
-              } else if (valueType === '[object Uint16Array]') {
-                  marker += TYPE_UINT16ARRAY;
-              } else if (valueType === '[object Int32Array]') {
-                  marker += TYPE_INT32ARRAY;
-              } else if (valueType === '[object Uint32Array]') {
-                  marker += TYPE_UINT32ARRAY;
-              } else if (valueType === '[object Float32Array]') {
-                  marker += TYPE_FLOAT32ARRAY;
-              } else if (valueType === '[object Float64Array]') {
-                  marker += TYPE_FLOAT64ARRAY;
-              } else {
-                  callback(new Error('Failed to get type for BinaryArray'));
-              }
-          }
-
-          callback(marker + bufferToString(buffer));
-      } else if (valueType === '[object Blob]') {
-          // Conver the blob to a binaryArray and then to a string.
-          var fileReader = new FileReader();
-
-          fileReader.onload = function() {
-              // Backwards-compatible prefix for the blob type.
-              var str =
-                  BLOB_TYPE_PREFIX +
-                  value.type +
-                  '~' +
-                  bufferToString(this.result);
-
-              callback(SERIALIZED_MARKER + TYPE_BLOB + str);
-          };
-
-          fileReader.readAsArrayBuffer(value);
-      } else {
-          try {
-              callback(JSON.stringify(value));
-          } catch (e) {
-              console.error("Couldn't convert value into a JSON string: ", value);
-
-              callback(null, e);
-          }
-      }
+  function deserialize(value) {
+      return JSON.parse(value);
   }
 
-  // Deserialize data we've inserted into a value column/field. We place
-  // special markers into our strings to mark them as encoded; this isn't
-  // as nice as a meta field, but it's the only sane thing we can do whilst
-  // keeping localStorage support intact.
-  //
-  // Oftentimes this will just deserialize JSON content, but if we have a
-  // special marker (SERIALIZED_MARKER, defined above), we will extract
-  // some kind of arraybuffer/binary data/typed array out of the string.
-  function deserialize$1(value) {
-      // If we haven't marked this string as being specially serialized (i.e.
-      // something other than serialized JSON), we can just return it and be
-      // done with it.
-      if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== SERIALIZED_MARKER) {
-          return JSON.parse(value);
-      }
-
-      // The following code deals with deserializing some kind of Blob or
-      // TypedArray. First we separate out the type of data we're dealing
-      // with from the data itself.
-      var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH);
-      var type = value.substring(
-          SERIALIZED_MARKER_LENGTH,
-          TYPE_SERIALIZED_MARKER_LENGTH
-      );
-
-      var blobType;
-      // Backwards-compatible blob type serialization strategy.
-      // DBs created with older versions of localForage will simply not have the blob type.
-      if (type === TYPE_BLOB && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) {
-          var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX);
-          blobType = matcher[1];
-          serializedString = serializedString.substring(matcher[0].length);
-      }
-      var buffer = stringToBuffer(serializedString);
-
-      // Return the right type based on the code/type set during
-      // serialization.
-      switch (type) {
-          case TYPE_ARRAYBUFFER:
-              return buffer;
-          case TYPE_BLOB:
-              return createBlob([buffer], { type: blobType });
-          case TYPE_INT8ARRAY:
-              return new Int8Array(buffer);
-          case TYPE_UINT8ARRAY:
-              return new Uint8Array(buffer);
-          case TYPE_UINT8CLAMPEDARRAY:
-              return new Uint8ClampedArray(buffer);
-          case TYPE_INT16ARRAY:
-              return new Int16Array(buffer);
-          case TYPE_UINT16ARRAY:
-              return new Uint16Array(buffer);
-          case TYPE_INT32ARRAY:
-              return new Int32Array(buffer);
-          case TYPE_UINT32ARRAY:
-              return new Uint32Array(buffer);
-          case TYPE_FLOAT32ARRAY:
-              return new Float32Array(buffer);
-          case TYPE_FLOAT64ARRAY:
-              return new Float64Array(buffer);
-          default:
-              throw new Error('Unkown type: ' + type);
-      }
-  }
-
-  var localforageSerializer = {
-      serialize: serialize$1,
-      deserialize: deserialize$1};
-
   // Copyright 2014 Mozilla
   // Copyright 2015 Thodoris Greasidis
   // Copyright 2018-2025 JC Brand
@@ -7696,8 +7455,6 @@
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
-  const serialize = localforageSerializer['serialize'];
-  const deserialize = localforageSerializer['deserialize'];
   function isSessionStorageValid() {
       try {
           if (sessionStorage && 'setItem' in sessionStorage) {
@@ -7743,7 +7500,7 @@
               }
           }
       });
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   function getItem(key, callback) {
@@ -7759,7 +7516,7 @@
           }
           return null;
       });
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   function iterate(iterator, callback) {
@@ -7787,7 +7544,7 @@
           }
           return;
       });
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   // Same as sessionStorage's key() method, except takes a callback.
@@ -7807,7 +7564,7 @@
           }
           return result;
       });
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   function keys(callback) {
@@ -7823,7 +7580,7 @@
           }
           return keys;
       });
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   // Supply the number of keys in the datastore to the callback function.
@@ -7832,7 +7589,7 @@
       const promise = self.keys().then(function (keys) {
           return keys.length;
       });
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   function removeItem(key, callback) {
@@ -7840,7 +7597,7 @@
       const promise = this.ready().then(function () {
           sessionStorage.removeItem(dbInfo.keyPrefix + key);
       });
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   async function setItem(key, value, callback) {
@@ -7852,27 +7609,27 @@
           dbInfo.serializer.serialize(value, (serializedValue, error) => {
               if (error) {
                   reject(error);
-                  executeCallback$1(Promise.reject(error), callback);
+                  chainCallback(Promise.reject(error), callback);
                   return;
               }
               try {
                   sessionStorage.setItem(dbInfo.keyPrefix + key, serializedValue);
                   resolve(originalValue);
-                  executeCallback$1(Promise.resolve(originalValue), callback);
+                  chainCallback(Promise.resolve(originalValue), callback);
               }
               catch (e) {
                   if (e.name === 'QuotaExceededError' || e.name === 'NS_ERROR_DOM_QUOTA_REACHED') {
                       console.error('Your sessionStorage capacity is used up.');
                   }
                   reject(e);
-                  executeCallback$1(Promise.reject(e), callback);
+                  chainCallback(Promise.reject(e), callback);
               }
           });
       });
   }
-  function dropInstance(options, callback) {
-      callback = getCallback.apply(this, arguments);
-      options = (typeof options !== 'function' && options) || {};
+  function dropInstance(...args) {
+      const callback = getCallback(...args);
+      let options = (typeof args[0] !== 'function' && args[0]) || {};
       if (!options.name) {
           const currentConfig = this.config();
           options.name = options.name || currentConfig.name;
@@ -7900,7 +7657,7 @@
               }
           });
       }
-      executeCallback$1(promise, callback);
+      chainCallback(promise, callback);
       return promise;
   }
   const sessionStorageWrapper = {
@@ -8379,10 +8136,10 @@
   extendPrototype(localForage);
 
   /** Used for built-in method references. */
-  var objectProto$6 = Object.prototype;
+  var objectProto$7 = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+  var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
 
   /**
    * The base implementation of `_.has` without support for deep paths.
@@ -8393,7 +8150,7 @@
    * @returns {boolean} Returns `true` if `key` exists, else `false`.
    */
   function baseHas(object, key) {
-    return object != null && hasOwnProperty$5.call(object, key);
+    return object != null && hasOwnProperty$6.call(object, key);
   }
 
   /** Used to match property names within property paths. */
@@ -8550,7 +8307,7 @@
     if (isArray(value)) {
       return value;
     }
-    return isKey(value, object) ? [value] : stringToPath(toString$2(value));
+    return isKey(value, object) ? [value] : stringToPath(toString$1(value));
   }
 
   /**
@@ -8704,16 +8461,18 @@
           wrapper.reject = reject;
       });
       Object.assign(promise, wrapper);
-      promise.then(function (v) {
+      // This `then` only mirrors settlement into the state flags. It must NOT
+      // rethrow on rejection: the derived promise is discarded, so rethrowing would
+      // surface as an unhandled rejection whenever the promise is rejected. The real
+      // consumer still awaits `promise` itself, which rejects normally.
+      promise.then(function () {
           promise.isResolved = true;
           promise.isPending = false;
           promise.isRejected = false;
-          return v;
-      }, function (e) {
+      }, function () {
           promise.isResolved = false;
           promise.isPending = false;
           promise.isRejected = true;
-          throw e;
       });
       return promise;
   }
@@ -8721,13 +8480,16 @@
   function urlError() {
       throw new Error('A "url" property or function must be specified');
   }
-  // Wrap an optional error callback with a fallback error event.
-  function wrapError(model, options) {
+  // Wrap an optional error callback with a fallback error event. When a
+  // `promise` is supplied (the `{ promise: true }` fetch/save path), the error is
+  // also forwarded to `promise.reject` so the returned promise settles on failure.
+  function wrapError(model, options, promise) {
       const error = options.error;
       options.error = function (resp) {
           if (error)
               error.call(options.context, model, resp, options);
           model.trigger('error', model, resp, options);
+          promise && promise.reject && promise.reject(resp);
       };
   }
   // Map from CRUD to HTTP for our default `sync` implementation.
@@ -8738,8 +8500,44 @@
       delete: 'DELETE',
       read: 'GET',
   };
+  // Tracks the classes we've already warned about, so the `browserStorage`
+  // deprecation notice is logged at most once per class rather than once per
+  // instance (a collection can resolve storage once per contained model).
+  const warnedBrowserStorage = new WeakSet();
+  /**
+   * Emit a one-time-per-class deprecation warning nudging downstream code from
+   * the `browserStorage` alias to the canonical `storage` accessor.
+   */
+  function warnBrowserStorageDeprecation(obj) {
+      const ctor = obj?.constructor;
+      if (!ctor || warnedBrowserStorage.has(ctor))
+          return;
+      warnedBrowserStorage.add(ctor);
+      const name = ctor.name;
+      console.warn(`Skeletor: \`browserStorage\` is deprecated and will be removed in a future major version; ` +
+          `use \`storage\` instead${name ? ` (on \`${name}\`)` : ''}.`);
+  }
+  /**
+   * Return the PersistentStorage instance configured on `obj`, checking both
+   * the canonical `storage` accessor and the deprecated `browserStorage` alias
+   * so that subclasses that still override `get browserStorage()` continue to work.
+   * @public
+   */
+  function getStorage(obj) {
+      if (!obj)
+          return undefined;
+      const storage = result(obj, 'storage');
+      if (storage != null)
+          return storage;
+      // Fall back to the deprecated alias; warn only when it actually supplies the
+      // store, so storage-less models/collections don't trip the notice.
+      const legacy = result(obj, 'browserStorage');
+      if (legacy != null)
+          warnBrowserStorageDeprecation(obj);
+      return legacy;
+  }
   function getSyncMethod(model) {
-      const store = result(model, 'browserStorage') || result(model.collection, 'browserStorage');
+      const store = getStorage(model) || getStorage(model.collection);
       return store ? store.sync() : sync;
   }
   /**
@@ -8789,15 +8587,56 @@
   localForage.defineDriver(memoryDriver);
   localforageSetitemsExports.extendPrototype(localForage);
   extendPrototype(localForage);
+  // Every storage instance is registered with a WeakRef so that flushAll() can
+  // reach pending writes without keeping instances alive. There's no leak and no
+  // lifecycle hook to maintain: an instance is collected once its owning model or
+  // collection is gone, at which point nothing is writing through it anyway.
+  // Models with a pending debounced save stay reachable via the autosync `pending`
+  // map until the timer fires, so flushAll() always reaches in-flight writes.
+  const weakInstances = new Set();
+  // Tracks which instances already have a WeakRef in `weakInstances`, so repeated
+  // `storage =` assignments (or a store shared across models) don't register the
+  // same instance twice and make flushAll() flush it more than once.
+  const registered = new WeakSet();
   /**
    * @public
    */
-  class BrowserStorage {
+  class PersistentStorage {
+      /** Register a storage instance with a weak reference. @public */
+      static register(instance) {
+          if (registered.has(instance))
+              return;
+          registered.add(instance);
+          weakInstances.add(new WeakRef(instance));
+      }
+      /**
+       * Flush the debounced write buffer of every registered PersistentStorage
+       * instance. Called automatically on pagehide/visibilitychange when autoSync
+       * is in use; can also be called manually.
+       * @public
+       */
+      static flushAll() {
+          for (const ref of weakInstances) {
+              const instance = ref.deref();
+              if (!instance) {
+                  weakInstances.delete(ref);
+              }
+              else {
+                  instance.flush();
+              }
+          }
+      }
       constructor(id, type, batchedWrites = false) {
-          if (type === 'local' && !window.localStorage) {
+          // Set once `storeInitialized` resolves. Lets `sync()` skip awaiting it on the
+          // hot path so a save buffers/issues its write *synchronously*, which is what
+          // makes the synchronous unload flush (`flushPending` -> `flushAll`) able to
+          // push a pending write out before the page is torn down.
+          this.storeReady = false;
+          this.name = id;
+          if (type === 'local' && typeof window !== 'undefined' && !window.localStorage) {
               throw new Error('Skeletor.storage: Environment does not support localStorage.');
           }
-          else if (type === 'session' && !window.sessionStorage) {
+          else if (type === 'session' && typeof window !== 'undefined' && !window.sessionStorage) {
               throw new Error('Skeletor.storage: Environment does not support sessionStorage.');
           }
           if (isString(type)) {
@@ -8812,10 +8651,13 @@
               }
               this.storeInitialized = Promise.resolve();
           }
-          this.name = id;
+          // Flip the synchronous-readiness flag once init settles. Callers that await
+          // `storeInitialized` directly still see any rejection; this branch only
+          // exists to set the flag and must not raise an unhandled rejection.
+          this.storeInitialized.then(() => (this.storeReady = true)).catch(() => { });
       }
       /**
-       * @param type - The storage type: 'local', 'session', 'indexed', or 'in_memory'
+       * @param type - The storage type: 'local', 'session', 'indexed', 'node', or 'in_memory'
        * @param batchedWrites - Whether to enable batched writes
        */
       async initStore(type, batchedWrites) {
@@ -8828,6 +8670,16 @@
           else if (type === 'in_memory') {
               await localForage.config({ 'driver': IN_MEMORY });
           }
+          else if (type === 'node') {
+              const { NodeSQLiteStorage } = await import('./drivers/nodeSQLiteStorage');
+              this.store = new NodeSQLiteStorage(this.name);
+              if (batchedWrites) {
+                  this.store.debouncedSetItems = mergebounce((items) => this.store.setItems(items), 50, {
+                      'promise': true,
+                  });
+              }
+              return;
+          }
           else if (type !== 'indexed') {
               throw new Error('Skeletor.storage: No storage type was specified');
           }
@@ -8844,6 +8696,7 @@
           }
       }
       async clear() {
+          await this.storeInitialized;
           await this.store.removeItem(this.name).catch((e) => console.error(e));
           const re = new RegExp(`^${this.name}-`);
           const keys = await this.store.keys();
@@ -8858,12 +8711,16 @@
               // We get the collection (and if necessary the model attribute.
               // Waiting for storeInitialized will cause another iteration of
               // the event loop, after which the collection reference will
-              // be removed from the model.
-              const collection = model.collection;
+              // be removed from the model. `options.collection` lets a deferred
+              // delete (sequenced behind an in-flight auto-save by Model.destroy)
+              // supply the collection captured before its optimistic removal.
+              const collection = options.collection ?? model.collection;
               if (['patch', 'update'].includes(method)) {
                   new_attributes = cloneDeep(model.attributes);
               }
-              await that.storeInitialized;
+              // Skip `await` if not necessary to allow for sync flushing
+              if (!that.storeReady)
+                  await that.storeInitialized;
               try {
                   const original_attributes = model.attributes;
                   switch (method) {
@@ -9018,8 +8875,8 @@
           return this.name + '-' + id;
       }
   }
-  BrowserStorage.sessionStorageInitialized = localForage.defineDriver(sessionStorageWrapper);
-  BrowserStorage.localForage = localForage;
+  PersistentStorage.sessionStorageInitialized = localForage.defineDriver(sessionStorageWrapper);
+  PersistentStorage.localForage = localForage;
 
   /** Used to compose bitmasks for cloning. */
   var CLONE_SYMBOLS_FLAG$1 = 4;
@@ -9169,7 +9026,7 @@
    * @name has
    * @memberOf SetCache
    * @param {*} value The value to search for.
-   * @returns {number} Returns `true` if `value` is found, else `false`.
+   * @returns {boolean} Returns `true` if `value` is found, else `false`.
    */
   function setCacheHas(value) {
     return this.__data__.has(value);
@@ -9452,10 +9309,10 @@
   var COMPARE_PARTIAL_FLAG$3 = 1;
 
   /** Used for built-in method references. */
-  var objectProto$5 = Object.prototype;
+  var objectProto$6 = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+  var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
 
   /**
    * A specialized version of `baseIsEqualDeep` for objects with support for
@@ -9483,7 +9340,7 @@
     var index = objLength;
     while (index--) {
       var key = objProps[index];
-      if (!(isPartial ? key in other : hasOwnProperty$4.call(other, key))) {
+      if (!(isPartial ? key in other : hasOwnProperty$5.call(other, key))) {
         return false;
       }
     }
@@ -9544,10 +9401,10 @@
       objectTag = '[object Object]';
 
   /** Used for built-in method references. */
-  var objectProto$4 = Object.prototype;
+  var objectProto$5 = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+  var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
 
   /**
    * A specialized version of `baseIsEqual` for arrays and objects which performs
@@ -9590,8 +9447,8 @@
         : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
     }
     if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
-      var objIsWrapped = objIsObj && hasOwnProperty$3.call(object, '__wrapped__'),
-          othIsWrapped = othIsObj && hasOwnProperty$3.call(other, '__wrapped__');
+      var objIsWrapped = objIsObj && hasOwnProperty$4.call(object, '__wrapped__'),
+          othIsWrapped = othIsObj && hasOwnProperty$4.call(other, '__wrapped__');
 
       if (objIsWrapped || othIsWrapped) {
         var objUnwrapped = objIsWrapped ? object.value() : object,
@@ -9965,10 +9822,10 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto$3 = Object.prototype;
+  var objectProto$4 = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+  var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
 
   /**
    * Creates an object composed of keys generated from the results of running
@@ -9993,7 +9850,7 @@
    * // => { '3': 2, '5': 1 }
    */
   var countBy = createAggregator(function(result, value, key) {
-    if (hasOwnProperty$2.call(result, key)) {
+    if (hasOwnProperty$3.call(result, key)) {
       ++result[key];
     } else {
       baseAssignValue(result, key, 1);
@@ -10001,10 +9858,10 @@
   });
 
   /** Used for built-in method references. */
-  var objectProto$2 = Object.prototype;
+  var objectProto$3 = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
+  var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
 
   /**
    * Creates an object composed of keys generated from the results of running
@@ -10030,7 +9887,7 @@
    * // => { '3': ['one', 'two'], '5': ['three'] }
    */
   var groupBy = createAggregator(function(result, value, key) {
-    if (hasOwnProperty$1.call(result, key)) {
+    if (hasOwnProperty$2.call(result, key)) {
       result[key].push(value);
     } else {
       baseAssignValue(result, key, [value]);
@@ -10247,7 +10104,7 @@
         if (isArray(iteratee)) {
           return function(value) {
             return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
-          }
+          };
         }
         return iteratee;
       });
@@ -10312,11 +10169,130 @@
     return baseOrderBy(collection, baseFlatten(iteratees), []);
   });
 
+  const pending = new Map();
+  const inFlight = new Set();
+  // Per-object view of `inFlight`, so a caller (notably `Model.destroy`) can
+  // await the saves for a single object without blocking on unrelated writes.
+  const inFlightByObj = new Map();
+  let unloadListenerAttached = false;
+  /**
+   * Execute a save `run` now and track the resulting promise as in-flight until
+   * it settles, both globally (`inFlight`) and per object (`inFlightByObj`), so
+   * `flushPending({ wait: true })` can await every save and `Model.destroy` can
+   * await just its own.
+   *
+   * @internal
+   * @param obj - The owning model/collection (or `null` when the save isn't tied to one).
+   *    A rejection is logged and re-surfaced on `obj`'s `error` event.
+   *    Called when a debounce timer fires or a flush forces it.
+   */
+  function fireRun(obj, run) {
+      const p = Promise.resolve(run()).catch((e) => {
+          console.error('Skeletor autoSync save error:', e);
+          // Surface failures that bypassed `options.error` on the model's `error` event,
+          // the same channel storage-layer failures already use. Storage saves route
+          // errors through `options.error` and then resolve, so they never reach this
+          // catch and won't double-emit.
+          obj?.trigger?.('error', obj, e);
+      });
+      inFlight.add(p);
+      let perObj;
+      if (obj) {
+          perObj = inFlightByObj.get(obj);
+          if (!perObj) {
+              perObj = new Set();
+              inFlightByObj.set(obj, perObj);
+          }
+          perObj.add(p);
+      }
+      p.finally(() => {
+          inFlight.delete(p);
+          if (perObj) {
+              perObj.delete(p);
+              if (perObj.size === 0)
+                  inFlightByObj.delete(obj);
+          }
+      });
+  }
+  /**
+   * Schedule a debounced auto-save for `obj`. Replaces any pending schedule
+   * for the same object.
+   * @internal
+   */
+  function scheduleAutoSave(obj, run, delay) {
+      const existing = pending.get(obj);
+      if (existing)
+          clearTimeout(existing.timerId);
+      const timerId = setTimeout(() => {
+          pending.delete(obj);
+          fireRun(obj, run);
+      }, delay);
+      pending.set(obj, { timerId, run });
+  }
+  /**
+   * Cancel any pending auto-save for `obj`.
+   *
+   * This only stops a *pending* (not-yet-fired) debounce timer. A save whose
+   * timer has already fired is in flight and beyond cancellation — sequence
+   * against it with {@link awaitInFlightSaves} instead.
+   * @internal
+   */
+  function cancelAutoSave(obj) {
+      const existing = pending.get(obj);
+      if (existing) {
+          clearTimeout(existing.timerId);
+          pending.delete(obj);
+      }
+  }
+  /**
+   * Return a promise that settles once every in-flight auto-save for `obj` has
+   * completed, or `null` when none are in flight. `Model.destroy` uses this to
+   * sequence its delete after a save that has already fired, so a late write
+   * cannot land after the delete and resurrect the record.
+   * @internal
+   */
+  function awaitInFlightSaves(obj) {
+      const set = inFlightByObj.get(obj);
+      if (!set || set.size === 0)
+          return null;
+      return Promise.all([...set]).then(() => undefined);
+  }
+  function flushPending({ storage, wait = false, } = {}) {
+      for (const [obj, { timerId, run }] of pending.entries()) {
+          clearTimeout(timerId);
+          fireRun(obj, run);
+      }
+      pending.clear();
+      if (storage)
+          storage.flushAll();
+      if (wait)
+          return Promise.all([...inFlight]).then(() => undefined);
+  }
+  /**
+   * Lazily attach pagehide/visibilitychange listeners in browser environments
+   * to flush pending writes when the page is hidden/unloading. This is a
+   * best-effort durability measure: the flush initiates writes synchronously but
+   * cannot guarantee an asynchronous backend finishes persisting them before the
+   * page goes away. Called at most once.
+   * @internal
+   */
+  function ensureUnloadListener(storage) {
+      if (unloadListenerAttached || typeof window === 'undefined')
+          return;
+      unloadListenerAttached = true;
+      const flush = () => flushPending({ storage });
+      window.addEventListener('pagehide', flush);
+      window.addEventListener('visibilitychange', () => {
+          if (document.visibilityState === 'hidden')
+              flush();
+      });
+  }
+
   /** Used for built-in method references. */
-  var objectProto$1 = Object.prototype;
+  var objectProto$2 = Object.prototype;
 
   /** Used to check objects for own properties. */
-  var hasOwnProperty = objectProto$1.hasOwnProperty;
+  var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
 
   /**
    * Assigns own and inherited enumerable string keyed properties of source
@@ -10361,7 +10337,7 @@
         var value = object[key];
 
         if (value === undefined ||
-            (eq(value, objectProto$1[key]) && !hasOwnProperty.call(object, key))) {
+            (eq(value, objectProto$2[key]) && !hasOwnProperty$1.call(object, key))) {
           object[key] = source[key];
         }
       }
@@ -10445,14 +10421,14 @@
   }
 
   /** Used for built-in method references. */
-  var objectProto = Object.prototype;
+  var objectProto$1 = Object.prototype;
 
   /**
    * Used to resolve the
    * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
    * of values.
    */
-  var nativeObjectToString = objectProto.toString;
+  var nativeObjectToString = objectProto$1.toString;
 
   /**
    * Creates an object composed of the inverted keys and values of `object`.
@@ -10623,6 +10599,12 @@
     return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
   }
 
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
   /**
    * The base implementation of `_.unset`.
    *
@@ -10633,8 +10615,34 @@
    */
   function baseUnset(object, path) {
     path = castPath(path, object);
-    object = parent(object, path);
-    return object == null || delete object[toKey(last(path))];
+
+    // Prevent prototype pollution:
+    // https://github.com/lodash/lodash/security/advisories/GHSA-xxjr-mmjv-4gpg
+    // https://github.com/lodash/lodash/security/advisories/GHSA-f23m-r3pf-42rh
+    var index = -1,
+        length = path.length;
+
+    if (!length) {
+      return true;
+    }
+
+    while (++index < length) {
+      var key = toKey(path[index]);
+
+      // Always block "__proto__" anywhere in the path if it's not expected
+      if (key === '__proto__' && !hasOwnProperty.call(object, '__proto__')) {
+        return false;
+      }
+
+      // Block constructor/prototype as non-terminal traversal keys to prevent
+      // escaping the object graph into built-in constructors and prototypes.
+      if ((key === 'constructor' || key === 'prototype') && index < length - 1) {
+        return false;
+      }
+    }
+
+    var obj = parent(object, path);
+    return obj == null || delete obj[toKey(last(path))];
   }
 
   /**
@@ -10832,6 +10840,7 @@
     return object == null ? {} : basePick(object, paths);
   });
 
+  var _Model_instances, _Model_computedCache, _Model_computedDefs, _Model_state, _Model_hydrate, _Model_doAutoSave, _Model_updateComputed, _Model_initComputed;
   /**
    * @public
    * **Models** are the basic data object in the framework --
@@ -10846,6 +10855,10 @@
        */
       constructor(attributes, options) {
           super();
+          _Model_instances.add(this);
+          _Model_computedCache.set(this, void 0);
+          _Model_computedDefs.set(this, void 0);
+          _Model_state.set(this, 'constructing');
           this._changing = false;
           this._pending = false;
           this._url = '';
@@ -10863,15 +10876,74 @@
           const default_attrs = result(this, 'defaults');
           attrs = defaults(Object.assign({}, default_attrs, attrs), default_attrs);
           this.set(attrs, options);
+          __classPrivateFieldGet(this, _Model_instances, "m", _Model_initComputed).call(this);
+          this.attrs = new Proxy(this.attributes, {
+              get: (_target, key) => {
+                  if (typeof key !== 'symbol' && __classPrivateFieldGet(this, _Model_computedCache, "f") && key in __classPrivateFieldGet(this, _Model_computedCache, "f")) {
+                      return __classPrivateFieldGet(this, _Model_computedCache, "f")[key];
+                  }
+                  return this.attributes[key];
+              },
+              set: (_target, key, value) => {
+                  this.set(key, value);
+                  return true;
+              },
+          });
           this.initialize.apply(this, arguments);
           // Reset changed after initial set
           this.changed = {};
+          // When autoSync is on, `initialized` is always a Promise so callers can
+          // uniformly `await model.initialized`. It only hydrates from storage when
+          // there's something to load (storage configured and the model isn't new);
+          // otherwise it's already ready and resolves immediately.
+          if (this.autoSync) {
+              if (getStorage(this) && !this.isNew()) {
+                  __classPrivateFieldSet(this, _Model_state, 'hydrating', "f");
+                  this.initialized = __classPrivateFieldGet(this, _Model_instances, "m", _Model_hydrate).call(this);
+              }
+              else {
+                  __classPrivateFieldSet(this, _Model_state, 'ready', "f");
+                  this.initialized = Promise.resolve();
+              }
+          }
+          else {
+              __classPrivateFieldSet(this, _Model_state, 'ready', "f");
+          }
+      }
+      /**
+       * The canonical storage accessor. Set to a `PersistentStorage` instance
+       * to enable local persistence for this model.
+       */
+      get storage() {
+          return this._storage;
       }
-      set browserStorage(storage) {
-          this._browserStorage = storage;
+      set storage(s) {
+          this._storage = s;
+          PersistentStorage.register(s);
       }
+      /**
+       * @deprecated Use `storage` instead.
+       */
       get browserStorage() {
-          return this._browserStorage;
+          return this._storage;
+      }
+      set browserStorage(s) {
+          warnBrowserStorageDeprecation(this);
+          this.storage = s;
+      }
+      /**
+       * Override to enable automatic persistence. When true, any `set()` call
+       * that changes attributes will schedule a debounced save to `storage`, and
+       * the model will auto-hydrate from storage on construction.
+       */
+      get autoSync() {
+          return false;
+      }
+      /**
+       * Debounce delay (ms) for auto-save writes. Override to tune.
+       */
+      get autoSyncDelay() {
+          return 100;
       }
       /**
        * The default name for the JSON `id` attribute is `"id"`. MongoDB and
@@ -10907,6 +10979,17 @@
       defaults() {
           return {};
       }
+      /**
+       * Declare computed properties. Override in subclasses to define properties
+       * that derive their value from other attributes. Each entry specifies the
+       * attribute keys it depends on (`deps`) and a function (`fn`) that receives
+       * the model and returns the computed value. The value is cached and
+       * recalculated automatically when any dep changes, firing a `change:key`
+       * event.
+       */
+      get computed() {
+          return {};
+      }
       /**
        * Return a copy of the model's `attributes` object.
        */
@@ -10920,9 +11003,12 @@
           return getSyncMethod(model)(method, model, options);
       }
       /**
-       * Get the value of an attribute.
+       * Get the value of an attribute, or a computed property.
        */
       get(attr) {
+          if (__classPrivateFieldGet(this, _Model_computedCache, "f") && attr in __classPrivateFieldGet(this, _Model_computedCache, "f")) {
+              return __classPrivateFieldGet(this, _Model_computedCache, "f")[attr];
+          }
           return this.attributes[attr];
       }
       keys() {
@@ -10987,6 +11073,11 @@
               attrs[key] = val;
           }
           options = options || {};
+          // Guard must come after arg normalization: when called as set(obj, opts),
+          // fromStorage lives in `val` (second arg), not `options` (third arg).
+          if (this.autoSync && __classPrivateFieldGet(this, _Model_state, "f") === 'hydrating' && !options.fromStorage) {
+              throw new Error(`Skeletor: set() called on an autoSync model before initialized resolved. Await model.initialized first.`);
+          }
           // Run validation.
           if (!this._validate(attrs, options))
               return null;
@@ -11027,6 +11118,14 @@
                   this.trigger('change:' + changes[i], this, current[changes[i]], options);
               }
           }
+          // Recalculate computed properties whose deps changed.
+          if (changes.length && __classPrivateFieldGet(this, _Model_computedDefs, "f")) {
+              for (const [key, def] of Object.entries(__classPrivateFieldGet(this, _Model_computedDefs, "f"))) {
+                  if (def.deps.some((dep) => changes.includes(dep))) {
+                      __classPrivateFieldGet(this, _Model_instances, "m", _Model_updateComputed).call(this, key, def, silent, options);
+                  }
+              }
+          }
           if (changing)
               return this;
           if (!silent) {
@@ -11040,6 +11139,17 @@
           }
           this._pending = false;
           this._changing = false;
+          // Auto-save: schedule a debounced write when autoSync is on and there
+          // were actual changes that originated from application code (not a
+          // storage read or an explicit noAutoSave call).
+          if (__classPrivateFieldGet(this, _Model_state, "f") === 'ready' &&
+              this.autoSync &&
+              getStorage(this) &&
+              changes.length &&
+              !options.fromStorage &&
+              !options.noAutoSave) {
+              scheduleAutoSave(this, () => __classPrivateFieldGet(this, _Model_instances, "m", _Model_doAutoSave).call(this), this.autoSyncDelay);
+          }
           return this;
       }
       /**
@@ -11114,16 +11224,48 @@
       fetch(options = {}) {
           options = Object.assign({ parse: true }, options);
           const success = options.success;
+          const promise = options.promise ? getResolveablePromise() : undefined;
+          // Tracks whether sync invoked one of the callbacks. A sync may instead
+          // settle its returned promise; the `.then`/`.catch` below bridges that to
+          // the callbacks so the fetch promise never hangs. The flag is set
+          // synchronously inside each callback (before sync's promise resolves), so
+          // it's reliable by the time those handlers run.
+          let settled = false;
           options.success = (resp) => {
+              settled = true;
               const serverAttrs = options.parse ? this.parse(resp, options) : resp;
-              if (!this.set(serverAttrs, options))
+              // fromStorage prevents the set() from triggering auto-save on reads
+              if (!this.set(serverAttrs, Object.assign({}, options, { fromStorage: true })))
                   return false;
               if (success)
                   success.call(options.context, this, resp, options);
               this.trigger('sync', this, resp, options);
+              promise && promise.resolve(resp);
           };
-          wrapError(this, options);
-          return this.sync('read', this, options);
+          wrapError(this, options, promise);
+          if (promise) {
+              const onError = options.error;
+              options.error = (resp) => {
+                  settled = true;
+                  onError(resp);
+              };
+          }
+          const result = this.sync('read', this, options);
+          if (promise) {
+              Promise.resolve(result).then(
+              // A sync that resolves its promise without invoking options.success:
+              // treat the resolved value as the response, so the model is still
+              // merged and the promise settles instead of hanging.
+              (value) => {
+                  if (!settled)
+                      options.success(value);
+              }, 
+              // A sync that rejects instead of invoking options.error; settling
+              // twice is a harmless no-op.
+              (e) => promise.reject(e));
+              return promise;
+          }
+          return result;
       }
       /**
        * Set a hash of model attributes, and sync the model to the server.
@@ -11200,6 +11342,7 @@
        * If `wait: true` is passed, waits for the server to respond before removal.
        */
       destroy(options) {
+          cancelAutoSave(this);
           options = options ? clone(options) : {};
           const success = options.success;
           const wait = options.wait;
@@ -11215,13 +11358,25 @@
               if (!this.isNew())
                   this.trigger('sync', this, resp, options);
           };
+          // A debounced auto-save may already have fired and be in flight.
+          // cancelAutoSave() above only stops a *pending* timer, so sequence the
+          // delete after any in-flight save; otherwise the late write could land
+          // after the delete and resurrect the record. Capture the collection now,
+          // the optimistic in-memory removal below nulls `model.collection` before
+          // the deferred sync runs, but the storage layer still needs it to drop
+          // this id from the collection's persisted index.
+          const inFlightSave = awaitInFlightSaves(this);
+          if (inFlightSave && this.collection)
+              options.collection = this.collection;
           let xhr = false;
           if (this.isNew()) {
               defer(options.success);
           }
           else {
               wrapError(this, options);
-              xhr = this.sync('delete', this, options);
+              xhr = inFlightSave
+                  ? inFlightSave.then(() => this.sync('delete', this, options))
+                  : this.sync('delete', this, options);
           }
           if (!wait)
               destroy();
@@ -11269,6 +11424,14 @@
       isValid(options) {
           return this._validate({}, Object.assign({}, options, { validate: true }));
       }
+      subscribe(eventOrCallback, callback, context) {
+          if (typeof eventOrCallback === 'function') {
+              const cb = (model) => eventOrCallback(model, this.changed);
+              this.on('change', cb);
+              return () => this.off('change', cb);
+          }
+          return super.subscribe(eventOrCallback, callback, context);
+      }
       /**
        * Run validation against the next complete set of model attributes,
        * returning `true` if all is well. Otherwise, fire an `"invalid"` event.
@@ -11284,8 +11447,43 @@
           return false;
       }
   }
+  _Model_computedCache = new WeakMap(), _Model_computedDefs = new WeakMap(), _Model_state = new WeakMap(), _Model_instances = new WeakSet(), _Model_hydrate = async function _Model_hydrate() {
+      ensureUnloadListener(PersistentStorage);
+      try {
+          await this.fetch({ fromStorage: true, promise: true });
+      }
+      catch (e) {
+          // 'Record Not Found' is a normal first-run state (nothing stored yet);
+          // keep the initial attributes and resolve. Re-throw anything else.
+          if (e !== 'Record Not Found')
+              throw e;
+      }
+      finally {
+          __classPrivateFieldSet(this, _Model_state, 'ready', "f");
+      }
+  }, _Model_doAutoSave = function _Model_doAutoSave() {
+      return this.save(null, { noAutoSave: true });
+  }, _Model_updateComputed = function _Model_updateComputed(key, def, silent, options) {
+      const newVal = def.fn(this);
+      if (!isEqual(__classPrivateFieldGet(this, _Model_computedCache, "f")[key], newVal)) {
+          __classPrivateFieldGet(this, _Model_computedCache, "f")[key] = newVal;
+          if (!silent) {
+              this.changed[key] = newVal;
+              this.trigger('change:' + key, this, newVal, options);
+          }
+      }
+  }, _Model_initComputed = function _Model_initComputed() {
+      const defs = result(this, 'computed');
+      if (!defs || isEmpty(defs))
+          return;
+      __classPrivateFieldSet(this, _Model_computedDefs, defs, "f");
+      __classPrivateFieldSet(this, _Model_computedCache, {}, "f");
+      for (const [key, def] of Object.entries(defs)) {
+          __classPrivateFieldGet(this, _Model_computedCache, "f")[key] = def.fn(this);
+      }
+  };
 
-  var _a;
+  var _Collection_instances, _Collection_hydrate, _a;
   // Default options for `Collection#set`.
   const setOptions = { add: true, remove: true, merge: true };
   const addOptions = { add: true, remove: false };
@@ -11306,6 +11504,7 @@
        */
       constructor(models, options) {
           super();
+          _Collection_instances.add(this);
           this._url = '';
           /**
            * @public
@@ -11323,6 +11522,12 @@
           if (models)
               this.reset(models, Object.assign({ silent: true }, options));
           this[Symbol.iterator] = this.values;
+          // When autoSync is on, `initialized` is always a Promise so callers can
+          // uniformly `await collection.initialized`; it resolves immediately when
+          // there's no storage to hydrate from.
+          if (this.autoSync) {
+              this.initialized = getStorage(this) ? __classPrivateFieldGet(this, _Collection_instances, "m", _Collection_hydrate).call(this) : Promise.resolve();
+          }
       }
       get comparator() {
           return this._comparator;
@@ -11330,11 +11535,40 @@
       set comparator(c) {
           this._comparator = c;
       }
-      set browserStorage(storage) {
-          this._browserStorage = storage;
+      /**
+       * The canonical storage accessor. Set to a `PersistentStorage` instance
+       * to enable local persistence for this collection.
+       */
+      get storage() {
+          return this._storage;
+      }
+      set storage(s) {
+          this._storage = s;
+          PersistentStorage.register(s);
       }
+      /**
+       * @deprecated Use `storage` instead.
+       */
       get browserStorage() {
-          return this._browserStorage;
+          return this._storage;
+      }
+      set browserStorage(s) {
+          warnBrowserStorageDeprecation(this);
+          this.storage = s;
+      }
+      /**
+       * Override to return `true` to automatically load the collection from
+       * storage on construction. Await `initialized` to know when hydration
+       * is complete.
+       *
+       * Note: collection `autoSync` is hydrate-only. Unlike `Model`, it does
+       * **not** schedule auto-saves when the collection changes (`add`/`remove`/
+       * `reset`). Persisting members is each model's responsibility — enable
+       * `autoSync` on the contained model class and every model writes its own
+       * record. A collection-level write would be redundant with that.
+       */
+      get autoSync() {
+          return false;
       }
       /**
        * The default model for a collection is just a **Model**.
@@ -11529,7 +11763,7 @@
                   }));
               });
           }));
-          await this.browserStorage?.clear();
+          await getStorage(this)?.clear();
           this.reset();
       }
       /**
@@ -11767,17 +12001,47 @@
           const success = options.success;
           // eslint-disable-next-line @typescript-eslint/no-this-alias
           const collection = this;
-          const promise = options.promise && getResolveablePromise();
+          const promise = options.promise ? getResolveablePromise() : undefined;
+          // Tracks whether sync invoked one of the callbacks. A sync may instead
+          // settle its returned promise; the `.then`/`.catch` below bridges that to
+          // the callbacks so the fetch promise never hangs. The flag is set
+          // synchronously inside each callback (before sync's promise resolves), so
+          // it's reliable by the time those handlers run.
+          let settled = false;
           options.success = function (resp) {
+              settled = true;
               const method = options.reset ? 'reset' : 'set';
-              collection[method](resp, options);
+              // fromStorage prevents individual model set() calls from triggering auto-save on reads
+              collection[method](resp, Object.assign({}, options, { fromStorage: true }));
               if (success)
                   success.call(options.context, collection, resp, options);
               promise && promise.resolve();
               collection.trigger('sync', collection, resp, options);
           };
-          wrapError(this, options);
-          return promise ? promise : this.sync('read', this, options);
+          wrapError(this, options, promise);
+          if (promise) {
+              const onError = options.error;
+              options.error = (resp) => {
+                  settled = true;
+                  onError(resp);
+              };
+          }
+          const result = this.sync('read', this, options);
+          if (promise) {
+              Promise.resolve(result).then(
+              // A sync that resolves its promise without invoking options.success:
+              // treat the resolved value as the response, so the collection is still
+              // populated and the promise settles instead of hanging.
+              (value) => {
+                  if (!settled)
+                      options.success(value);
+              }, 
+              // A sync that rejects instead of invoking options.error; settling
+              // twice is a harmless no-op.
+              (e) => promise.reject(e));
+              return promise;
+          }
+          return result;
       }
       /**
        * Create a new instance of a model in this collection. Add the model to the
@@ -11821,6 +12085,14 @@
               return preparedModel;
           }
       }
+      subscribe(eventOrCallback, callback, context) {
+          if (typeof eventOrCallback === 'function') {
+              const cb = () => eventOrCallback(this);
+              this.on('update reset sort', cb);
+              return () => this.off('update reset sort', cb);
+          }
+          return super.subscribe(eventOrCallback, callback, context);
+      }
       /**
        * **parse** converts a response into a list of models to be added to the
        * collection. The default implementation is just to pass it through.
@@ -11958,7 +12230,12 @@
           this.trigger.apply(this, arguments);
       }
   }
-  _a = Symbol.iterator;
+  _Collection_instances = new WeakSet(), _Collection_hydrate = async function _Collection_hydrate() {
+      ensureUnloadListener(PersistentStorage);
+      // findAll() returns [] for an empty store, so a first-run collection
+      // resolves rather than erroring the way a model fetch-by-id would.
+      await this.fetch({ fromStorage: true, promise: true });
+  }, _a = Symbol.iterator;
   // This "enum" defines the three possible kinds of values which can be emitted
   // by a CollectionIterator that correspond to the values(), keys() and entries()
   // methods on Collection, respectively.
@@ -12047,12 +12324,19 @@
   }
   skeletor.noConflict = noConflict;
   root.Skeletor = skeletor;
+  /**
+   * @deprecated Use `PersistentStorage` instead.
+   * @public
+   */
+  const BrowserStorage = PersistentStorage;
 
   exports.BrowserStorage = BrowserStorage;
   exports.Collection = Collection;
   exports.EventEmitter = EventEmitter;
   exports.Model = Model;
+  exports.PersistentStorage = PersistentStorage;
   exports.default = skeletor;
+  exports.getStorage = getStorage;
   exports.noConflict = noConflict;
   exports.sync = sync;