@converse/skeletor 3.1.6 → 4.0.1

package/dist/skeletor.js

@@ -1674,19 +1674,6 @@
       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;
@@ -8477,6 +8464,16 @@
       // Generate a pseudo-GUID by concatenating random hexadecimal.
       return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
   }
+  // Helpers
+  // -------
+  /**
+   * Whether `value` is a thenable (a promise, or a promise-like object such as
+   * a jqXHR). Decides whether a `sync` return value can be bridged to the
+   * promise that `fetch`/`save` hand back.
+   */
+  function isThenable(value) {
+      return value != null && typeof value.then === 'function';
+  }
   function getResolveablePromise() {
       const wrapper = {
           isResolved: false,
@@ -8521,6 +8518,65 @@
           promise && promise.reject && promise.reject(resp);
       };
   }
+  /**
+   * Run a `sync` and make sure `promise` settles from its outcome, however the
+   * sync reports it.
+   *
+   * A `sync` may invoke `options.success`/`options.error` (the callback
+   * contract), or settle the promise it returns without calling them: a
+   * promise-only custom sync, or an async sync whose promise rejects because a
+   * `'sync'`/`'error'` listener threw after the callbacks ran. `options.success`
+   * and `options.error` must already be wired to resolve/reject `promise`. This
+   * wraps them to record that they ran, calls `run()`, and bridges a thenable
+   * result to them so the promise never hangs:
+   *
+   * - fulfilment with the callbacks unrun is delivered to `options.success`, so
+   *   the response is still merged into the model or collection;
+   * - rejection with the callbacks unrun is delivered to `options.error`, so the
+   *   caller's `error` callback and the `'error'` event still fire;
+   * - rejection after the callbacks ran rejects `promise` directly: a no-op if
+   *   they already settled it, and the only way to settle it if a listener threw
+   *   before they could;
+   * - a throw from either delivery (a throwing `success`/`error` callback or
+   *   listener) rejects `promise` instead of surfacing as an unhandled rejection.
+   *
+   * A non-thenable result (a callback-only sync that returns nothing, or an
+   * XHR) is left alone: such a sync settles `promise` through its callbacks, and
+   * bridging it would fire `success` on the next microtask, before the sync is
+   * done. Without a `promise`, `run()` is called as is.
+   */
+  function bridgeSyncToPromise(options, promise, run) {
+      if (!promise)
+          return run();
+      let settled = false;
+      const success = options.success;
+      const error = options.error;
+      options.success = (...args) => {
+          settled = true;
+          return success && success(...args);
+      };
+      options.error = (...args) => {
+          settled = true;
+          return error && error(...args);
+      };
+      const result = run();
+      if (isThenable(result)) {
+          Promise.resolve(result)
+              .then((value) => {
+              if (!settled)
+                  options.success(value);
+          }, (e) => {
+              if (settled) {
+                  promise.reject(e);
+              }
+              else {
+                  options.error(e);
+              }
+          })
+              .catch((e) => promise.reject(e));
+      }
+      return result;
+  }
   // Map from CRUD to HTTP for our default `sync` implementation.
   const methodMap = {
       create: 'POST',
@@ -8570,43 +8626,77 @@
       return store ? store.sync() : sync;
   }
   /**
-   * Override this function to change the manner in which Backbone persists
-   * models to the server. You will be passed the type of request, and the
-   * model in question. By default makes a `fetch()` API call
-   * to the model's `url()`.
-   *
-   * Some possible customizations could be:
-   *
-   * - Use `setTimeout` to batch rapid-fire updates into a single request.
-   * - Persist models via WebSockets instead of Ajax.
-   * - Persist models to browser storage
+   * The error the default `sync` hands to `options.error`, and rejects with, for
+   * a response outside the 2xx range.
+   * @public
    */
+  class HTTPError extends Error {
+      constructor(response, method, url) {
+          const statusText = response.statusText ? ` ${response.statusText}` : '';
+          super(`${method} ${url} failed with HTTP ${response.status}${statusText}`);
+          this.name = 'HTTPError';
+          this.status = response.status;
+          this.response = response;
+      }
+  }
   /**
+   * The default `sync`: a JSON request over `fetch()` to the model's `url()`.
+   * Override it (or `Model.sync`/`Collection.sync`) to change how models are
+   * persisted, for instance to batch rapid-fire updates with `setTimeout`, to
+   * talk over WebSockets, or to write to browser storage.
+   *
+   * It honours both contracts a `sync` may use. On a 2xx response the JSON body
+   * (`null` when the body is empty) is passed to `options.success` and the
+   * returned promise resolves with it. On a non-2xx response, a network failure
+   * or an unparsable body, `options.error` receives the error (an `HTTPError`
+   * for the first) and the promise rejects with it.
+   *
+   * `options.data` is sent as query parameters on GET, which may not carry a
+   * body, and as a JSON body otherwise. For create, update and patch the body
+   * defaults to `options.attrs` or the model's `toJSON()`.
    * @public
    */
   function sync(method, model, options = {}) {
+      const type = methodMap[method];
       let data = options.data;
       // Ensure that we have the appropriate request data.
       if (data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
           data = options.attrs || model.toJSON();
       }
-      const type = methodMap[method];
-      const params = {
-          method: type,
-          body: data ? JSON.stringify(data) : '',
-          headers: {
-              'Content-Type': 'application/json',
-          },
-          success: options.success,
-          error: options.error,
-      };
-      const url = options.url || result(model, 'url') || urlError();
-      const xhr = fetch(url, params);
-      if (options) {
-          options.xhr = xhr;
+      let url = options.url || result(model, 'url') || urlError();
+      const params = { method: type };
+      if (data != null) {
+          if (type === 'GET') {
+              url += (url.includes('?') ? '&' : '?') + new URLSearchParams(data).toString();
+          }
+          else {
+              params.body = JSON.stringify(data);
+              params.headers = { 'Content-Type': 'application/json' };
+          }
       }
+      const xhr = fetch(url, params);
+      options.xhr = xhr;
       model.trigger('request', model, xhr, { ...params, xhr });
-      return xhr;
+      return Promise.resolve(xhr)
+          .then(async (response) => {
+          if (!response.ok)
+              throw new HTTPError(response, type, url);
+          const text = await response.text();
+          return text ? JSON.parse(text) : null;
+      })
+          .then(
+      // The callbacks run before the returned promise settles, so a caller that
+      // bridges this promise (`Model.fetch`/`save`) sees the outcome as already
+      // reported. A throw from `success` (a `'sync'` listener, say) is not
+      // routed to `error`: it rejects the promise, which is what the bridge
+      // expects once the callbacks have run.
+      (resp) => {
+          options.success?.(resp, options);
+          return resp;
+      }, (e) => {
+          options.error?.(e);
+          throw e;
+      });
   }
 
   /**
@@ -9972,6 +10062,48 @@
     baseAssignValue(result, key, value);
   });
 
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG$1 = 1;
+
+  /**
+   * Creates a function that performs a partial deep comparison between a given
+   * object and `source`, returning `true` if the given object has equivalent
+   * property values, else `false`.
+   *
+   * **Note:** The created function is equivalent to `_.isMatch` with `source`
+   * partially applied.
+   *
+   * Partial comparisons will match empty array and empty object `source`
+   * values against any array or object value, respectively. See `_.isEqual`
+   * for a list of supported value comparisons.
+   *
+   * **Note:** Multiple values can be checked by combining several matchers
+   * using `_.overSome`
+   *
+   * @static
+   * @memberOf _
+   * @since 3.0.0
+   * @category Util
+   * @param {Object} source The object of property values to match.
+   * @returns {Function} Returns the new spec function.
+   * @example
+   *
+   * var objects = [
+   *   { 'a': 1, 'b': 2, 'c': 3 },
+   *   { 'a': 4, 'b': 5, 'c': 6 }
+   * ];
+   *
+   * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
+   * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
+   *
+   * // Checking for several possible values
+   * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));
+   * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
+   */
+  function matches(source) {
+    return baseMatches(baseClone(source, CLONE_DEEP_FLAG$1));
+  }
+
   /** Built-in value references. */
   var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : undefined;
 
@@ -10535,53 +10667,36 @@
     return baseIsEqual(value, other);
   }
 
-  /** Used to compose bitmasks for cloning. */
-  var CLONE_DEEP_FLAG$1 = 1;
-
   /**
-   * Creates a function that invokes `func` with the arguments of the created
-   * function. If `func` is a property name, the created function returns the
-   * property value for a given element. If `func` is an array or object, the
-   * created function returns `true` for elements that contain the equivalent
-   * source properties, otherwise it returns `false`.
+   * Performs a partial deep comparison between `object` and `source` to
+   * determine if `object` contains equivalent property values.
+   *
+   * **Note:** This method is equivalent to `_.matches` when `source` is
+   * partially applied.
+   *
+   * Partial comparisons will match empty array and empty object `source`
+   * values against any array or object value, respectively. See `_.isEqual`
+   * for a list of supported value comparisons.
    *
    * @static
-   * @since 4.0.0
    * @memberOf _
-   * @category Util
-   * @param {*} [func=_.identity] The value to convert to a callback.
-   * @returns {Function} Returns the callback.
+   * @since 3.0.0
+   * @category Lang
+   * @param {Object} object The object to inspect.
+   * @param {Object} source The object of property values to match.
+   * @returns {boolean} Returns `true` if `object` is a match, else `false`.
    * @example
    *
-   * var users = [
-   *   { 'user': 'barney', 'age': 36, 'active': true },
-   *   { 'user': 'fred',   'age': 40, 'active': false }
-   * ];
-   *
-   * // The `_.matches` iteratee shorthand.
-   * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
-   * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
-   *
-   * // The `_.matchesProperty` iteratee shorthand.
-   * _.filter(users, _.iteratee(['user', 'fred']));
-   * // => [{ 'user': 'fred', 'age': 40 }]
+   * var object = { 'a': 1, 'b': 2 };
    *
-   * // The `_.property` iteratee shorthand.
-   * _.map(users, _.iteratee('user'));
-   * // => ['barney', 'fred']
-   *
-   * // Create custom iteratee shorthands.
-   * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
-   *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
-   *     return func.test(string);
-   *   };
-   * });
+   * _.isMatch(object, { 'b': 2 });
+   * // => true
    *
-   * _.filter(['abc', 'def'], /ef/);
-   * // => ['def']
+   * _.isMatch(object, { 'b': 1 });
+   * // => false
    */
-  function iteratee(func) {
-    return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG$1));
+  function isMatch(object, source) {
+    return object === source || baseIsMatch(object, source, getMatchData(source));
   }
 
   /**
@@ -10886,7 +11001,47 @@
     return object == null ? {} : basePick(object, paths);
   });
 
-  var _Model_instances, _Model_computedCache, _Model_computedDefs, _Model_state, _Model_hydrate, _Model_doAutoSave, _Model_updateComputed, _Model_initComputed;
+  const INTERNALS = new WeakMap();
+  function internals(model) {
+      let priv = INTERNALS.get(model);
+      if (!priv) {
+          priv = { state: 'constructing' };
+          INTERNALS.set(model, priv);
+      }
+      return priv;
+  }
+  /** Load the model from storage, marking it ready whether or not the read succeeds. */
+  async function hydrate$1(model, priv) {
+      ensureUnloadListener(PersistentStorage);
+      try {
+          await model.fetch({ fromStorage: true, promise: true });
+      }
+      finally {
+          priv.state = 'ready';
+      }
+  }
+  /** Evaluate the model's declared computed properties once, seeding the cache. */
+  function initComputed(model, priv) {
+      const defs = result(model, 'computed');
+      if (!defs || isEmpty(defs))
+          return;
+      priv.computedDefs = defs;
+      priv.computedCache = {};
+      for (const [key, def] of Object.entries(defs)) {
+          priv.computedCache[key] = def.fn(model);
+      }
+  }
+  /** Recompute one computed property, firing `change:key` when its value changed. */
+  function updateComputed(model, priv, key, def, silent, options) {
+      const newVal = def.fn(model);
+      if (!isEqual(priv.computedCache[key], newVal)) {
+          priv.computedCache[key] = newVal;
+          if (!silent) {
+              model.changed[key] = newVal;
+              model.trigger('change:' + key, model, newVal, options);
+          }
+      }
+  }
   /**
    * @public
    * **Models** are the basic data object in the framework --
@@ -10901,15 +11056,12 @@
        */
       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 = '';
           this.changed = {};
           this.validationError = null;
+          const priv = internals(this);
           let attrs = attributes || {};
           options = options || {};
           this.preinitialize.apply(this, arguments);
@@ -10922,11 +11074,12 @@
           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);
+          initComputed(this, priv);
           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];
+                  const cache = priv.computedCache;
+                  if (typeof key !== 'symbol' && cache && key in cache) {
+                      return cache[key];
                   }
                   return this.attributes[key];
               },
@@ -10944,16 +11097,16 @@
           // otherwise it's already ready and resolves immediately.
           if (this.autoSync) {
               if (getStorage(this) && !this.isNew()) {
-                  __classPrivateFieldSet(this, _Model_state, 'hydrating', "f");
-                  this.hydrated = __classPrivateFieldGet(this, _Model_instances, "m", _Model_hydrate).call(this);
+                  priv.state = 'hydrating';
+                  this.hydrated = hydrate$1(this, priv);
               }
               else {
-                  __classPrivateFieldSet(this, _Model_state, 'ready', "f");
+                  priv.state = 'ready';
                   this.hydrated = Promise.resolve();
               }
           }
           else {
-              __classPrivateFieldSet(this, _Model_state, 'ready', "f");
+              priv.state = 'ready';
           }
       }
       /**
@@ -11052,8 +11205,9 @@
        * 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];
+          const cache = internals(this).computedCache;
+          if (cache && attr in cache) {
+              return cache[attr];
           }
           return this.attributes[attr];
       }
@@ -11095,10 +11249,20 @@
           return this.get(attr) != null;
       }
       /**
-       * Special-cased proxy to lodash's `matches` method.
+       * Returns `true` if the model's attributes satisfy `attrs`.
+       *
+       * An attributes object is compared with lodash's `isMatch`: a partial, deep
+       * comparison, so `{ form: { type: 'hidden' } }` matches a `form` attribute
+       * that has `type: 'hidden'` alongside other keys. A function is called with
+       * the attributes and its result coerced to a boolean.
+       *
+       * To scan a collection, prefer `Collection#find`, `filter` or `where`. They
+       * build their matcher once per scan instead of once per model.
        */
       matches(attrs) {
-          return !!iteratee(attrs)(this.attributes);
+          if (typeof attrs === 'function')
+              return !!attrs(this.attributes);
+          return isMatch(this.attributes, attrs);
       }
       /**
        * Set a hash of model attributes on the object, firing `"change"`. This is
@@ -11119,9 +11283,10 @@
               attrs[key] = val;
           }
           options = options || {};
+          const priv = internals(this);
           // 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) {
+          if (this.autoSync && priv.state === 'hydrating' && !options.fromStorage) {
               throw new Error(`Skeletor: set() called on an autoSync model before hydration resolved. Await model.hydrated first.`);
           }
           // Run validation.
@@ -11165,10 +11330,10 @@
               }
           }
           // 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 (changes.length && priv.computedDefs) {
+              for (const [key, def] of Object.entries(priv.computedDefs)) {
                   if (def.deps.some((dep) => changes.includes(dep))) {
-                      __classPrivateFieldGet(this, _Model_instances, "m", _Model_updateComputed).call(this, key, def, silent, options);
+                      updateComputed(this, priv, key, def, silent, options);
                   }
               }
           }
@@ -11188,13 +11353,13 @@
           // 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' &&
+          if (priv.state === 'ready' &&
               this.autoSync &&
               getStorage(this) &&
               changes.length &&
               !options.fromStorage &&
               !options.noAutoSave) {
-              scheduleAutoSave(this, () => __classPrivateFieldGet(this, _Model_instances, "m", _Model_doAutoSave).call(this), this.autoSyncDelay);
+              scheduleAutoSave(this, () => this.save(null, { noAutoSave: true }), this.autoSyncDelay);
           }
           return this;
       }
@@ -11271,47 +11436,25 @@
           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;
               // fromStorage prevents the set() from triggering auto-save on reads
-              if (!this.set(serverAttrs, Object.assign({}, options, { fromStorage: true })))
+              if (!this.set(serverAttrs, Object.assign({}, options, { fromStorage: true }))) {
+                  // The fetched attributes failed validation (`'invalid'` has fired).
+                  // Settle the promise with the error rather than leave it pending.
+                  promise && promise.reject(this.validationError);
                   return false;
+              }
               if (success)
                   success.call(options.context, this, resp, options);
               this.trigger('sync', this, resp, options);
               promise && promise.resolve(resp);
           };
           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;
+          // With `promise`, the sync's outcome is bridged to it however the sync
+          // reports it: through the callbacks, or through the promise it returns.
+          const result = bridgeSyncToPromise(options, promise, () => this.sync('read', this, options));
+          return promise ?? result;
       }
       /**
        * Set a hash of model attributes, and sync the model to the server.
@@ -11332,16 +11475,19 @@
           options = Object.assign({ validate: true, parse: true }, options);
           const wait = options.wait;
           const return_promise = options.promise;
-          const promise = return_promise && getResolveablePromise();
+          const promise = return_promise ? getResolveablePromise() : undefined;
           // If we're not waiting and attributes exist, save acts as
           // `set(attr).save(null, opts)` with validation. Otherwise, check if
           // the model will be valid when the attributes, if any, are set.
-          if (attrs && !wait) {
-              if (!this.set(attrs, options))
+          const valid = attrs && !wait ? !!this.set(attrs, options) : this._validate(attrs || {}, options);
+          if (!valid) {
+              // Nothing is synced (`'invalid'` has fired). With `promise`, hand back a
+              // rejected promise rather than `false`, so the promise contract holds
+              // for every outcome.
+              if (!promise)
                   return false;
-          }
-          else if (!this._validate(attrs || {}, options)) {
-              return false;
+              promise.reject(this.validationError);
+              return promise;
           }
           // After a successful server-side save, the client is (optionally)
           // updated with the server-side state.
@@ -11354,8 +11500,12 @@
               let serverAttrs = options.parse ? this.parse(resp, options) : resp;
               if (wait)
                   serverAttrs = Object.assign({}, attrs, serverAttrs);
-              if (serverAttrs && !this.set(serverAttrs, options))
+              if (serverAttrs && !this.set(serverAttrs, options)) {
+                  // The server attributes failed validation (`'invalid'` has fired).
+                  // Settle the promise with the error rather than leave it pending.
+                  return_promise && promise.reject(this.validationError);
                   return false;
+              }
               if (success)
                   success.call(options.context, this, resp, options);
               this.trigger('sync', this, resp, options);
@@ -11372,15 +11522,12 @@
           const method = this.isNew() ? 'create' : options.patch ? 'patch' : 'update';
           if (method === 'patch' && !options.attrs)
               options.attrs = attrs;
-          const xhr = this.sync(method, this, options);
+          // With `promise`, the sync's outcome is bridged to it however the sync
+          // reports it: through the callbacks, or through the promise it returns.
+          const xhr = bridgeSyncToPromise(options, promise, () => this.sync(method, this, options));
           // Restore attributes.
           this.attributes = attributes;
-          if (return_promise) {
-              return promise;
-          }
-          else {
-              return xhr;
-          }
+          return promise ?? xhr;
       }
       /**
        * Destroy this model on the server if it was already persisted.
@@ -11493,40 +11640,40 @@
           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 });
-      }
-      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 _Collection_instances, _Collection_hydrate, _a;
+  var _a;
   // Default options for `Collection#set`.
   const setOptions = { add: true, remove: true, merge: true };
   const addOptions = { add: true, remove: false };
+  /**
+   * Normalizes the predicate forms accepted by the query methods into one
+   * `(model) => value` function. A function is used as-is, a string reads that
+   * attribute, and an attributes object becomes a lodash `matches` matcher.
+   *
+   * The matcher is built here, once per scan. Calling `Model#matches` per model
+   * instead rebuilds the match data for every model visited, which made
+   * `findWhere` an order of magnitude slower than a hand-written predicate.
+   */
+  function toModelPredicate(pred) {
+      if (isFunction(pred))
+          return pred;
+      if (isString(pred))
+          return (m) => m.get(pred);
+      const matcher = matches(pred);
+      return (m) => matcher(m.attributes);
+  }
+  /**
+   * Load the collection's members from storage. A module-level function rather
+   * than a `#private` method so the published declarations carry no private
+   * members, which TypeScript 6 rejects in anonymously extended classes (TS4094).
+   */
+  async function hydrate(collection) {
+      ensureUnloadListener(PersistentStorage);
+      // An empty store is a normal first-run state: findAll() returns [] and a
+      // missing model record resolves to null, so hydration resolves rather
+      // than rejecting.
+      await collection.fetch({ fromStorage: true, promise: true });
+  }
   /**
    * @public
    * If models tend to represent a single row of data, a Collection is
@@ -11544,7 +11691,6 @@
        */
       constructor(models, options) {
           super();
-          _Collection_instances.add(this);
           this._url = '';
           /**
            * @public
@@ -11566,7 +11712,7 @@
           // uniformly `await collection.hydrated`; it resolves immediately when
           // there's no storage to hydrate from.
           if (this.autoSync) {
-              this.hydrated = getStorage(this) ? __classPrivateFieldGet(this, _Collection_instances, "m", _Collection_hydrate).call(this) : Promise.resolve();
+              this.hydrated = getStorage(this) ? hydrate(this) : Promise.resolve();
           }
       }
       get comparator() {
@@ -11855,17 +12001,13 @@
           return this.models.slice(start, end);
       }
       filter(callback, thisArg) {
-          return this.models.filter(isFunction(callback)
-              ? callback
-              : (m) => m.matches(callback), thisArg);
+          return this.models.filter(toModelPredicate(callback), thisArg);
       }
       every(pred) {
           if (isFunction(pred)) {
-              return this.models.map((m) => m.attributes).every(pred);
-          }
-          else {
-              return this.models.every((m) => m.matches(pred));
+              return this.models.every((m) => pred(m.attributes));
           }
+          return this.models.every(toModelPredicate(pred));
       }
       difference(values) {
           return this.models.filter((m) => !values.includes(m));
@@ -11881,16 +12023,12 @@
       }
       some(pred) {
           if (isFunction(pred)) {
-              return this.models.map((m) => m.attributes).some(pred);
-          }
-          else {
-              return this.models.some((m) => m.matches(pred));
+              return this.models.some((m) => pred(m.attributes));
           }
+          return this.models.some(toModelPredicate(pred));
       }
       sortBy(iteratee) {
-          return sortBy(this.models, isFunction(iteratee)
-              ? iteratee
-              : (m) => (isString(iteratee) ? m.get(iteratee) : m.matches(iteratee)));
+          return sortBy(this.models, toModelPredicate(iteratee));
       }
       isEmpty() {
           return !this.models.length;
@@ -11911,26 +12049,22 @@
           return this.models.length;
       }
       countBy(f) {
-          return countBy(this.models, isFunction(f) ? f : (m) => (isString(f) ? m.get(f) : m.matches(f)));
+          return countBy(this.models, toModelPredicate(f));
       }
       groupBy(pred) {
-          return groupBy(this.models, isFunction(pred) ? pred : (m) => (isString(pred) ? m.get(pred) : m.matches(pred)));
+          return groupBy(this.models, toModelPredicate(pred));
       }
       indexOf(model, fromIndex) {
           return this.models.indexOf(model, fromIndex);
       }
       findLastIndex(pred, fromIndex) {
-          return this.models.findLastIndex(isFunction(pred)
-              ? pred
-              : (m) => (isString(pred) ? m.get(pred) : m.matches(pred)), fromIndex);
+          return this.models.findLastIndex(toModelPredicate(pred), fromIndex);
       }
       lastIndexOf(model, fromIndex) {
           return this.models.lastIndexOf(model, fromIndex);
       }
       findIndex(pred) {
-          return this.models.findIndex(isFunction(pred)
-              ? pred
-              : (m) => (isString(pred) ? m.get(pred) : m.matches(pred)));
+          return this.models.findIndex(toModelPredicate(pred));
       }
       last() {
           const length = this.models == null ? 0 : this.models.length;
@@ -11943,9 +12077,7 @@
           return this.head();
       }
       map(cb, thisArg) {
-          return this.models.map(isFunction(cb)
-              ? cb
-              : (m) => (isString(cb) ? m.get(cb) : m.matches(cb)), thisArg);
+          return this.models.map(toModelPredicate(cb), thisArg);
       }
       reduce(callback, initialValue) {
           return this.models.reduce(callback, initialValue || this.models[0]);
@@ -11996,10 +12128,7 @@
           return this.where(attrs, true);
       }
       find(predicate, fromIndex) {
-          const pred = isFunction(predicate)
-              ? predicate
-              : (m) => m.matches(predicate);
-          return this.models.find(pred, fromIndex);
+          return this.models.find(toModelPredicate(predicate), fromIndex);
       }
       /**
        * Force the collection to re-sort itself. You don't need to call this under
@@ -12042,46 +12171,22 @@
           // eslint-disable-next-line @typescript-eslint/no-this-alias
           const collection = this;
           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';
               // 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();
+              // Fire 'sync' before resolving, as `Model.fetch`/`save` do, so a throwing
+              // listener rejects the promise instead of being lost.
               collection.trigger('sync', collection, resp, options);
+              promise && promise.resolve();
           };
           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;
+          // With `promise`, the sync's outcome is bridged to it however the sync
+          // reports it: through the callbacks, or through the promise it returns.
+          const result = bridgeSyncToPromise(options, promise, () => this.sync('read', this, options));
+          return promise ?? result;
       }
       /**
        * Create a new instance of a model in this collection. Add the model to the
@@ -12093,9 +12198,22 @@
           const wait = options.wait;
           const return_promise = options.promise;
           const promise = return_promise && getResolveablePromise();
+          // `_prepareModel` reports attributes that fail validation by firing
+          // `'invalid'` and returning null. With `promise`, capture that error so a
+          // rejected promise is handed back rather than `null`.
+          let validationError;
+          const captureInvalid = (_c, err) => (validationError = err);
+          if (return_promise)
+              this.on('invalid', captureInvalid);
           const preparedModel = this._prepareModel(model, options);
-          if (!preparedModel)
-              return null;
+          if (return_promise)
+              this.off('invalid', captureInvalid);
+          if (!preparedModel) {
+              if (!return_promise)
+                  return null;
+              promise.reject(validationError);
+              return promise;
+          }
           if (!wait)
               this.add(preparedModel, options);
           // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -12117,8 +12235,15 @@
               error && error.call(options.context, model, e, options);
               return_promise && promise.reject(e);
           };
-          preparedModel.save(null, Object.assign(options, { 'promise': false }));
+          // `options.promise` is passed through, so `save` installs its own bridge
+          // from the sync's returned promise to its callbacks: a sync that resolves
+          // without calling them still reaches the wired `options.success` above,
+          // which resolves our promise with the model. Only a rejection that bypassed
+          // the callbacks (a rejecting sync, or a throwing `'sync'`/`'error'`
+          // listener) still needs bridging to ours.
+          const result = preparedModel.save(null, options);
           if (return_promise) {
+              Promise.resolve(result).catch((e) => promise.reject(e));
               return promise;
           }
           else {
@@ -12270,13 +12395,7 @@
           this.trigger.apply(this, arguments);
       }
   }
-  _Collection_instances = new WeakSet(), _Collection_hydrate = async function _Collection_hydrate() {
-      ensureUnloadListener(PersistentStorage);
-      // An empty store is a normal first-run state: findAll() returns [] and a
-      // missing model record resolves to null, so hydration resolves rather
-      // than rejecting.
-      await this.fetch({ fromStorage: true, promise: true });
-  }, _a = Symbol.iterator;
+  _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.
@@ -12344,6 +12463,7 @@
       EventEmitter,
       Model,
       sync,
+      HTTPError,
   };
   // Establish the root object, `window` (`self`) in the browser, or `global` on the server.
   // We use `self` instead of `window` for `WebWorker` support.
@@ -12374,6 +12494,7 @@
   exports.BrowserStorage = BrowserStorage;
   exports.Collection = Collection;
   exports.EventEmitter = EventEmitter;
+  exports.HTTPError = HTTPError;
   exports.Model = Model;
   exports.PersistentStorage = PersistentStorage;
   exports.default = skeletor;