pervert-monkey 1.0.9 → 1.0.11

package/dist/core/pervertmonkey.core.es.js

@@ -28,6 +28,51 @@ function range(size, start = 1, step = 1) {
 function wait(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
+function memoize(fn2) {
+  const cache = /* @__PURE__ */ new Map();
+  const memoizedFunction = ((...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn2(...args);
+    cache.set(key, result);
+    return result;
+  });
+  return memoizedFunction;
+}
+function objectToFormData(obj) {
+  const formData = new FormData();
+  Object.entries(obj).forEach(([k2, v2]) => {
+    formData.append(k2, v2);
+  });
+  return formData;
+}
+class RegexFilter {
+  constructor(str, flags = "gi") {
+    __publicField(this, "regexes");
+    this.regexes = memoize(this.compileSearchRegex)(str, flags);
+  }
+  // 'dog,bog,f:girl' or r:dog|bog... => [r/dog/i, r/bog/i, r/(^|\ )girl($|\ )/i]
+  compileSearchRegex(str, flags) {
+    try {
+      if (str.startsWith("r:")) return [new RegExp(str.slice(2), flags)];
+      const regexes = splitWith(str).map(
+        (s) => s.replace(/f:(\w+)/g, (_2, w2) => `(^|\\ |,)${w2}($|\\ |,)`)
+        // full word
+      ).map((_2) => new RegExp(_2, flags));
+      return regexes;
+    } catch (_2) {
+      return [];
+    }
+  }
+  hasEvery(str) {
+    return this.regexes.every((r) => r.test(str));
+  }
+  hasNone(str) {
+    return this.regexes.every((r) => !r.test(str));
+  }
+}
 function splitWith(s, c = ",") {
   return s.split(c).map((s2) => s2.trim()).filter(Boolean);
 }
@@ -45,9 +90,9 @@ function waitForElementToAppear(parent, selector, callback) {
   observer.observe(document.body, { childList: true, subtree: true });
   return observer;
 }
-function waitForElementToDisappear(observable, callback) {
+function waitForElementToDisappear(observable2, callback) {
   const observer = new MutationObserver((_mutations) => {
-    if (!observable.isConnected) {
+    if (!observable2.isConnected) {
       observer.disconnect();
       callback();
     }
@@ -279,26 +324,6 @@ const fetchText = (input) => fetchWith(input, { type: "text" });
 function circularShift(n, c = 6, s = 1) {
   return (n + s) % c || c;
 }
-function memoize(fn2) {
-  const cache = /* @__PURE__ */ new Map();
-  const memoizedFunction = ((...args) => {
-    const key = JSON.stringify(args);
-    if (cache.has(key)) {
-      return cache.get(key);
-    }
-    const result = fn2(...args);
-    cache.set(key, result);
-    return result;
-  });
-  return memoizedFunction;
-}
-function objectToFormData(obj) {
-  const formData = new FormData();
-  Object.entries(obj).forEach(([k2, v2]) => {
-    formData.append(k2, v2);
-  });
-  return formData;
-}
 class LazyImgLoader {
   constructor(shouldDelazify) {
     __publicField(this, "lazyImgObserver");
@@ -347,26 +372,33 @@ class Observer {
     this.observer.disconnect();
   }
   static observeWhile(target, callback, throttleTime) {
-    const observer_ = new Observer(async (target2) => {
+    const observer = new Observer(async (target2) => {
       const condition = await callback();
-      if (condition) observer_.throttle(target2, throttleTime);
+      if (condition) {
+        observer.throttle(target2, throttleTime);
+      } else {
+        observer.dispose();
+      }
     });
-    observer_.observe(target);
-    return observer_;
+    observer.observe(target);
+    return observer;
   }
 }
 function formatTimeToHHMMSS(timeStr) {
   var _a3, _b2, _c2;
   const pad = (num) => num.toString().padStart(2, "0");
   const h = ((_a3 = timeStr.match(/(\d+)\s*h/)) == null ? void 0 : _a3[1]) || "0";
-  const m = ((_b2 = timeStr.match(/(\d+)\s*mi?n/)) == null ? void 0 : _b2[1]) || "0";
-  const s = ((_c2 = timeStr.match(/(\d+)\s*sec/)) == null ? void 0 : _c2[1]) || "0";
+  const m = ((_b2 = timeStr.match(/(\d+)\s*mi?n?/)) == null ? void 0 : _b2[1]) || "0";
+  const s = ((_c2 = timeStr.match(/(\d+)\s*se?c?/)) == null ? void 0 : _c2[1]) || "0";
   return `${pad(+h)}:${pad(+m)}:${pad(+s)}`;
 }
 function timeToSeconds(timeStr) {
   const normalized = /[a-zA-Z]/.test(timeStr) ? formatTimeToHHMMSS(timeStr) : timeStr;
   return normalized.split(":").reverse().reduce((total, unit, index) => total + parseInt(unit, 10) * 60 ** index, 0);
 }
+function parseUrl(s) {
+  return new URL(typeof s === "string" ? s : s.href);
+}
 function parseIntegerOr(n, or2) {
   const num = Number(n);
   return Number.isSafeInteger(num) ? num : or2;
@@ -392,31 +424,6 @@ function parseDataParams(str) {
 function parseCssUrl(s) {
   return s.replace(/url\("|"\).*/g, "");
 }
-class RegexFilter {
-  constructor(str, flags = "gi") {
-    __publicField(this, "regexes");
-    this.regexes = memoize(this.compileSearchRegex)(str, flags);
-  }
-  // 'dog,bog,f:girl' or r:dog|bog... => [r/dog/i, r/bog/i, r/(^|\ )girl($|\ )/i]
-  compileSearchRegex(str, flags) {
-    try {
-      if (str.startsWith("r:")) return [new RegExp(str.slice(2), flags)];
-      const regexes = splitWith(str).map(
-        (s) => s.replace(/f:(\w+)/g, (_2, w2) => `(^|\\ |,)${w2}($|\\ |,)`)
-        // full word
-      ).map((_2) => new RegExp(_2, flags));
-      return regexes;
-    } catch (_2) {
-      return [];
-    }
-  }
-  hasEvery(str) {
-    return this.regexes.every((r) => r.test(str));
-  }
-  hasNone(str) {
-    return this.regexes.every((r) => !r.test(str));
-  }
-}
 const _DataFilter = class _DataFilter {
   constructor(rules) {
     __publicField(this, "filters", /* @__PURE__ */ new Map());
@@ -432,11 +439,7 @@ const _DataFilter = class _DataFilter {
   applyCSSFilters(wrapper) {
     this.filters.forEach((_2, name) => {
       const cssRule = `.filter-${name} { display: none !important; }`;
-      if (wrapper) {
-        GM_addStyle(wrapper(cssRule));
-      } else {
-        GM_addStyle(cssRule);
-      }
+      GM_addStyle(wrapper ? wrapper(cssRule) : cssRule);
     });
   }
   registerFilters(customFilters) {
@@ -521,7 +524,7 @@ __publicField(_DataFilter, "customDataSelectorFnsDefault", {
 });
 let DataFilter = _DataFilter;
 class DataManager {
-  constructor(rules) {
+  constructor(rules, parseDataParentHomogenity) {
     __publicField(this, "data", /* @__PURE__ */ new Map());
     __publicField(this, "lazyImgLoader", new LazyImgLoader(
       (target) => !DataFilter.isFiltered(target)
@@ -567,9 +570,8 @@ class DataManager {
       );
       await this.applyFilters(filters, offset);
     });
-    __publicField(this, "parseDataParentHomogenity");
     __publicField(this, "parseData", (html, container, removeDuplicates = false, shouldLazify = true) => {
-      const thumbs = this.rules.getThumbs(html);
+      const thumbs = this.rules.thumbsParser.getThumbs(html);
       const dataOffset = this.data.size;
       const fragment = document.createDocumentFragment();
       const parent = container || this.rules.container;
@@ -584,10 +586,10 @@ class DataManager {
           if (removeDuplicates) thumbElement.remove();
           continue;
         }
-        const data = this.rules.getThumbData(thumbElement);
+        const data = this.rules.thumbDataParser.getThumbData(thumbElement);
         this.data.set(url, { element: thumbElement, ...data });
         if (shouldLazify) {
-          const { img, imgSrc } = this.rules.getThumbImgData(thumbElement);
+          const { img, imgSrc } = this.rules.thumbImgParser.getImgData(thumbElement);
           this.lazyImgLoader.lazify(thumbElement, img, imgSrc);
         }
         fragment.append(thumbElement);
@@ -599,6 +601,7 @@ class DataManager {
       });
     });
     this.rules = rules;
+    this.parseDataParentHomogenity = parseDataParentHomogenity;
     this.dataFilter = new DataFilter(this.rules);
   }
   sortBy(key, direction = true) {
@@ -615,25 +618,675 @@ class DataManager {
     container.style.visibility = "visible";
   }
 }
+var extendStatics = function(d2, b2) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d3, b3) {
+    d3.__proto__ = b3;
+  } || function(d3, b3) {
+    for (var p in b3) if (Object.prototype.hasOwnProperty.call(b3, p)) d3[p] = b3[p];
+  };
+  return extendStatics(d2, b2);
+};
+function __extends(d2, b2) {
+  if (typeof b2 !== "function" && b2 !== null)
+    throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
+  extendStatics(d2, b2);
+  function __() {
+    this.constructor = d2;
+  }
+  d2.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar2 = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar2.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar2;
+}
+function __spreadArray(to2, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar2; i < l; i++) {
+    if (ar2 || !(i in from)) {
+      if (!ar2) ar2 = Array.prototype.slice.call(from, 0, i);
+      ar2[i] = from[i];
+    }
+  }
+  return to2.concat(ar2 || Array.prototype.slice.call(from));
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+function isFunction(value) {
+  return typeof value === "function";
+}
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+var Subscription = (function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a3, e_2, _b2;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a3 = _parentage_1.return)) _a3.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b2 = _finalizers_1.return)) _b2.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription2.prototype.add = function(teardown) {
+    var _a3;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a3 = this._finalizers) !== null && _a3 !== void 0 ? _a3 : []).push(teardown);
+      }
+    }
+  };
+  Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription2) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription2.EMPTY = (function() {
+    var empty = new Subscription2();
+    empty.closed = true;
+    return empty;
+  })();
+  return Subscription2;
+})();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+var config = {
+  Promise: void 0
+};
+var timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    var args = [];
+    for (var _i4 = 2; _i4 < arguments.length; _i4++) {
+      args[_i4 - 2] = arguments[_i4];
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    return clearTimeout(handle);
+  },
+  delegate: void 0
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    {
+      throw err;
+    }
+  });
+}
+function noop() {
+}
+function errorContext(cb) {
+  {
+    cb();
+  }
+}
+var Subscriber = (function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber2.prototype.next = function(value) {
+    if (this.isStopped) ;
+    else {
+      this._next(value);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) ;
+    else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) ;
+    else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  };
+  Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber2;
+})(Subscription);
+var ConsumerObserver = (function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver2;
+})();
+var SafeSubscriber = (function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
+      };
+    } else {
+      {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+})(Subscriber);
+function handleUnhandledError(error) {
+  {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+var observable = (function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+})();
+function identity(x2) {
+  return x2;
+}
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function(prev, fn2) {
+      return fn2(prev);
+    }, input);
+  };
+}
+var Observable = (function() {
+  function Observable2(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable2.prototype.lift = function(operator) {
+    var observable2 = new Observable2();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  };
+  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function() {
+      var _a3 = _this, operator = _a3.operator, source = _a3.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  };
+  Observable2.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable2.prototype.forEach = function(next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function(value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
+  };
+  Observable2.prototype._subscribe = function(subscriber) {
+    var _a3;
+    return (_a3 = this.source) === null || _a3 === void 0 ? void 0 : _a3.subscribe(subscriber);
+  };
+  Observable2.prototype[observable] = function() {
+    return this;
+  };
+  Observable2.prototype.pipe = function() {
+    var operations = [];
+    for (var _i4 = 0; _i4 < arguments.length; _i4++) {
+      operations[_i4] = arguments[_i4];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable2.prototype.toPromise = function(promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var value;
+      _this.subscribe(function(x2) {
+        return value = x2;
+      }, function(err) {
+        return reject(err);
+      }, function() {
+        return resolve(value);
+      });
+    });
+  };
+  Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  };
+  return Observable2;
+})();
+function getPromiseCtor(promiseCtor) {
+  var _a3;
+  return (_a3 = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a3 !== void 0 ? _a3 : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+var ObjectUnsubscribedError = createErrorClass(function(_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = "ObjectUnsubscribedError";
+    this.message = "object unsubscribed";
+  };
+});
+var Subject = (function(_super) {
+  __extends(Subject2, _super);
+  function Subject2() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject2.prototype.lift = function(operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject2.prototype._throwIfClosed = function() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject2.prototype.next = function(value) {
+    var _this = this;
+    errorContext(function() {
+      var e_1, _a3;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b2 = __values(_this.currentObservers), _c2 = _b2.next(); !_c2.done; _c2 = _b2.next()) {
+            var observer = _c2.value;
+            observer.next(value);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (_c2 && !_c2.done && (_a3 = _b2.return)) _a3.call(_b2);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject2.prototype.error = function(err) {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject2.prototype.complete = function() {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject2.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject2.prototype, "observed", {
+    get: function() {
+      var _a3;
+      return ((_a3 = this.observers) === null || _a3 === void 0 ? void 0 : _a3.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject2.prototype._trySubscribe = function(subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject2.prototype._subscribe = function(subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject2.prototype._innerSubscribe = function(subscriber) {
+    var _this = this;
+    var _a3 = this, hasError = _a3.hasError, isStopped = _a3.isStopped, observers = _a3.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function() {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+    var _a3 = this, hasError = _a3.hasError, thrownError = _a3.thrownError, isStopped = _a3.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  };
+  Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  };
+  Subject2.create = function(destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject2;
+})(Observable);
+var AnonymousSubject = (function(_super) {
+  __extends(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject2.prototype.next = function(value) {
+    var _a3, _b2;
+    (_b2 = (_a3 = this.destination) === null || _a3 === void 0 ? void 0 : _a3.next) === null || _b2 === void 0 ? void 0 : _b2.call(_a3, value);
+  };
+  AnonymousSubject2.prototype.error = function(err) {
+    var _a3, _b2;
+    (_b2 = (_a3 = this.destination) === null || _a3 === void 0 ? void 0 : _a3.error) === null || _b2 === void 0 ? void 0 : _b2.call(_a3, err);
+  };
+  AnonymousSubject2.prototype.complete = function() {
+    var _a3, _b2;
+    (_b2 = (_a3 = this.destination) === null || _a3 === void 0 ? void 0 : _a3.complete) === null || _b2 === void 0 ? void 0 : _b2.call(_a3);
+  };
+  AnonymousSubject2.prototype._subscribe = function(subscriber) {
+    var _a3, _b2;
+    return (_b2 = (_a3 = this.source) === null || _a3 === void 0 ? void 0 : _a3.subscribe(subscriber)) !== null && _b2 !== void 0 ? _b2 : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject2;
+})(Subject);
 class InfiniteScroller {
   constructor(options) {
     __publicField(this, "enabled", true);
     __publicField(this, "paginationOffset", 1);
-    __publicField(this, "parseData");
     __publicField(this, "rules");
     __publicField(this, "observer");
     __publicField(this, "paginationGenerator");
-    __publicField(this, "onScrollCBs", []);
+    __publicField(this, "subject", new Subject());
     __publicField(this, "generatorConsumer", async () => {
       if (!this.enabled) return false;
-      const {
-        value: { url, offset },
-        done
-      } = await this.paginationGenerator.next();
-      if (!done && url) {
-        await this.doScroll(url, offset);
-      }
-      return !done;
+      const { value, done } = await this.paginationGenerator.next();
+      if (done) return false;
+      const { url, offset } = value;
+      await this.doScroll(url, offset);
+      return true;
     });
     this.rules = options.rules;
     this.paginationOffset = this.rules.paginationStrategy.getPaginationOffset();
@@ -648,79 +1301,162 @@ class InfiniteScroller {
   dispose() {
     if (this.observer) this.observer.dispose();
   }
-  setObserver(observable) {
+  setObserver(observable2) {
     if (this.observer) this.observer.dispose();
     this.observer = Observer.observeWhile(
-      observable,
+      observable2,
       this.generatorConsumer,
       this.rules.store.state.delay
     );
     return this;
   }
-  onScroll(callback, initCall = false) {
-    if (initCall) callback(this);
-    this.onScrollCBs.push(callback);
-    return this;
-  }
-  _onScroll() {
-    this.onScrollCBs.forEach((cb) => {
-      cb(this);
-    });
-  }
   setAutoScroll() {
     const autoScrollWrapper = async () => {
       if (this.rules.store.state.autoScroll) {
         await wait(this.rules.store.state.delay);
-        await this.generatorConsumer();
+        const res = await this.generatorConsumer();
+        if (!res) return;
         await autoScrollWrapper();
       }
     };
-    autoScrollWrapper();
-    this.rules.store.stateSubject.subscribe((type) => {
-      if (type == null ? void 0 : type.autoScroll) {
-        autoScrollWrapper();
-      }
+    autoScrollWrapper();
+    this.rules.store.stateSubject.subscribe((type) => {
+      if (type == null ? void 0 : type.autoScroll) {
+        autoScrollWrapper();
+      }
+    });
+  }
+  async getPaginationData(url) {
+    return await fetchHtml(url);
+  }
+  async doScroll(url, offset) {
+    const page = await this.getPaginationData(url);
+    const prevScrollPos = document.documentElement.scrollTop;
+    this.paginationOffset = Math.max(this.paginationOffset, offset);
+    this.subject.next({ type: "scroll", scroller: this, page });
+    window.scrollTo(0, prevScrollPos);
+    if (this.rules.store.state.writeHistory) {
+      history.replaceState({}, "", url);
+    }
+  }
+  static async *generatorForPaginationStrategy(pstrategy) {
+    const _offset = pstrategy.getPaginationOffset();
+    const end = pstrategy.getPaginationLast();
+    const urlGenerator = pstrategy.getPaginationUrlGenerator();
+    for (let offset = _offset; offset <= end; offset++) {
+      const url = await urlGenerator(offset);
+      yield { url, offset };
+    }
+  }
+  static create(rules) {
+    const enabled = rules.store.state.infiniteScrollEnabled;
+    rules.store.state.$paginationLast = rules.paginationStrategy.getPaginationLast();
+    const infiniteScroller = new InfiniteScroller({ enabled, rules });
+    rules.store.state.$paginationOffset = infiniteScroller.paginationOffset;
+    infiniteScroller.subject.subscribe((x2) => {
+      if (x2.type === "scroll") {
+        rules.store.state.$paginationOffset = x2.scroller.paginationOffset;
+        rules.dataManager.parseData(x2.page);
+      }
+    });
+    rules.store.stateSubject.subscribe(() => {
+      infiniteScroller.enabled = rules.store.state.infiniteScrollEnabled;
+    });
+    return infiniteScroller;
+  }
+}
+class PaginationStrategy {
+  constructor(options) {
+    __publicField(this, "doc", document);
+    __publicField(this, "url");
+    __publicField(this, "paginationSelector", ".pagination");
+    __publicField(this, "searchParamSelector", "page");
+    __publicField(this, "pathnameSelector", /\/(\d+)\/?$/);
+    __publicField(this, "dataparamSelector", "[data-parameters *= from]");
+    __publicField(this, "overwritePaginationLast");
+    __publicField(this, "offsetMin", 1);
+    if (options) {
+      Object.entries(options).forEach(([k2, v2]) => {
+        Object.assign(this, { [k2]: v2 });
+      });
+    }
+    this.url = parseUrl((options == null ? void 0 : options.url) || this.doc.URL);
+  }
+  getPaginationElement() {
+    return this.doc.querySelector(this.paginationSelector);
+  }
+  get hasPagination() {
+    return !!this.getPaginationElement();
+  }
+  getPaginationOffset() {
+    return this.offsetMin;
+  }
+  getPaginationLast() {
+    if (this.overwritePaginationLast) return this.overwritePaginationLast(1);
+    return 1;
+  }
+  getPaginationUrlGenerator() {
+    return (_2) => this.url.href;
+  }
+}
+__publicField(PaginationStrategy, "_pathnameSelector", /\/(page\/)?\d+\/?$/);
+class PaginationStrategyDataParams extends PaginationStrategy {
+  getPaginationLast() {
+    var _a3;
+    const links = (_a3 = this.getPaginationElement()) == null ? void 0 : _a3.querySelectorAll(this.dataparamSelector);
+    const pages = Array.from(links || [], (l) => {
+      var _a4;
+      const p = l.getAttribute("data-parameters");
+      const v2 = ((_a4 = p == null ? void 0 : p.match(/from\w*:(\d+)/)) == null ? void 0 : _a4[1]) || this.offsetMin.toString();
+      return parseInt(v2);
+    });
+    const lastPage = Math.max(...pages, this.offsetMin);
+    if (this.overwritePaginationLast) return this.overwritePaginationLast(lastPage);
+    return lastPage;
+  }
+  getPaginationOffset() {
+    var _a3, _b2;
+    const link = (_a3 = this.getPaginationElement()) == null ? void 0 : _a3.querySelector(
+      ".prev[data-parameters *= from], .prev [data-parameters *= from]"
+    );
+    if (!link) return this.offsetMin;
+    const p = link.getAttribute("data-parameters");
+    const v2 = ((_b2 = p == null ? void 0 : p.match(/from\w*:(\d+)/)) == null ? void 0 : _b2[1]) || this.offsetMin.toString();
+    return parseInt(v2);
+  }
+  getPaginationUrlGenerator() {
+    var _a3;
+    const url = new URL(this.url.href);
+    const parametersElement = (_a3 = this.getPaginationElement()) == null ? void 0 : _a3.querySelector(
+      "a[data-block-id][data-parameters]"
+    );
+    const block_id = (parametersElement == null ? void 0 : parametersElement.getAttribute("data-block-id")) || "";
+    const parameters = parseDataParams(
+      (parametersElement == null ? void 0 : parametersElement.getAttribute("data-parameters")) || ""
+    );
+    const attrs = {
+      block_id,
+      function: "get_block",
+      mode: "async",
+      ...parameters
+    };
+    Object.keys(attrs).forEach((k2) => {
+      url.searchParams.set(k2, attrs[k2]);
     });
+    const paginationUrlGenerator = (n) => {
+      Object.keys(attrs).forEach((k2) => {
+        k2.includes("from") && url.searchParams.set(k2, n.toString());
+      });
+      url.searchParams.set("_", Date.now().toString());
+      return url.href;
+    };
+    return paginationUrlGenerator;
   }
-  // consume api strategy
-  async getPaginationData(url) {
-    return await fetchHtml(url);
-  }
-  async doScroll(url, offset) {
-    var _a3;
-    const nextPageHtml = await this.getPaginationData(url);
-    const prevScrollPos = document.documentElement.scrollTop;
-    this.paginationOffset = Math.max(this.paginationOffset, offset);
-    (_a3 = this.parseData) == null ? void 0 : _a3.call(this, nextPageHtml);
-    this._onScroll();
-    window.scrollTo(0, prevScrollPos);
-    if (this.rules.store.state.writeHistory) {
-      history.replaceState({}, "", url);
-    }
-  }
-  static async *generatorForPaginationStrategy(pstrategy) {
-    const _offset = pstrategy.getPaginationOffset();
-    const end = pstrategy.getPaginationLast();
-    const urlGenerator = pstrategy.getPaginationUrlGenerator();
-    for (let offset = _offset; offset <= end; offset++) {
-      const url = await urlGenerator(offset);
-      yield { url, offset };
-    }
-  }
-  static create(rules) {
-    const enabled = rules.store.state.infiniteScrollEnabled;
-    rules.store.state.$paginationLast = rules.paginationStrategy.getPaginationLast();
-    const infiniteScroller = new InfiniteScroller({
-      enabled,
-      parseData: rules.dataManager.parseData,
-      rules
-    }).onScroll(({ paginationOffset }) => {
-      rules.store.state.$paginationOffset = paginationOffset;
-    }, true);
-    rules.store.stateSubject.subscribe(() => {
-      infiniteScroller.enabled = rules.store.state.infiniteScrollEnabled;
-    });
-    return infiniteScroller;
+  static testLinks(doc = document) {
+    const dataParamLinks = Array.from(
+      doc.querySelectorAll("[data-parameters *= from]")
+    );
+    return dataParamLinks.length > 0;
   }
 }
 var Pe$1 = Object.defineProperty;
@@ -1469,9 +2205,6 @@ var Y = (_b = class {
   }
 }, _i3 = new WeakMap(), _n3 = new WeakMap(), _t2 = new WeakMap(), _e3 = new WeakMap(), _s3 = new WeakMap(), _l3 = new WeakMap(), _b);
 a(Y, "URLPattern");
-function parseUrl(s) {
-  return new URL(typeof s === "string" ? s : s.href);
-}
 function depaginatePathname(url, pathnamePaginationSelector = /\/(page\/)?\d+\/?$/) {
   const newUrl = new URL(url.toString());
   newUrl.pathname = newUrl.pathname.replace(pathnamePaginationSelector, "/");
@@ -1500,100 +2233,6 @@ function upgradePathname(curr, links, pathnamePaginationSelector = /\/(page\/)?\
   if (last.pathname !== curr.pathname) curr.pathname = last.pathname;
   return curr;
 }
-class PaginationStrategy {
-  constructor(options) {
-    __publicField(this, "doc", document);
-    __publicField(this, "url");
-    __publicField(this, "paginationSelector", ".pagination");
-    __publicField(this, "searchParamSelector", "page");
-    __publicField(this, "pathnameSelector", /\/(\d+)\/?$/);
-    __publicField(this, "dataparamSelector", "[data-parameters *= from]");
-    __publicField(this, "overwritePaginationLast");
-    __publicField(this, "offsetMin", 1);
-    if (options) {
-      Object.entries(options).forEach(([k2, v2]) => {
-        Object.assign(this, { [k2]: v2 });
-      });
-    }
-    this.url = parseUrl((options == null ? void 0 : options.url) || this.doc.URL);
-  }
-  getPaginationElement() {
-    return this.doc.querySelector(this.paginationSelector);
-  }
-  get hasPagination() {
-    return !!this.getPaginationElement();
-  }
-  getPaginationOffset() {
-    return this.offsetMin;
-  }
-  getPaginationLast() {
-    if (this.overwritePaginationLast) return this.overwritePaginationLast(1);
-    return 1;
-  }
-  getPaginationUrlGenerator() {
-    return (_2) => this.url.href;
-  }
-}
-__publicField(PaginationStrategy, "_pathnameSelector", /\/(page\/)?\d+\/?$/);
-class PaginationStrategyDataParams extends PaginationStrategy {
-  getPaginationLast() {
-    var _a3;
-    const links = (_a3 = this.getPaginationElement()) == null ? void 0 : _a3.querySelectorAll(this.dataparamSelector);
-    const pages = Array.from(links || [], (l) => {
-      var _a4;
-      const p = l.getAttribute("data-parameters");
-      const v2 = ((_a4 = p == null ? void 0 : p.match(/from\w*:(\d+)/)) == null ? void 0 : _a4[1]) || this.offsetMin.toString();
-      return parseInt(v2);
-    });
-    const lastPage = Math.max(...pages, this.offsetMin);
-    if (this.overwritePaginationLast) return this.overwritePaginationLast(lastPage);
-    return lastPage;
-  }
-  getPaginationOffset() {
-    var _a3, _b2;
-    const link = (_a3 = this.getPaginationElement()) == null ? void 0 : _a3.querySelector(
-      ".prev[data-parameters *= from], .prev [data-parameters *= from]"
-    );
-    if (!link) return this.offsetMin;
-    const p = link.getAttribute("data-parameters");
-    const v2 = ((_b2 = p == null ? void 0 : p.match(/from\w*:(\d+)/)) == null ? void 0 : _b2[1]) || this.offsetMin.toString();
-    return parseInt(v2);
-  }
-  getPaginationUrlGenerator() {
-    var _a3;
-    const url = new URL(this.url.href);
-    const parametersElement = (_a3 = this.getPaginationElement()) == null ? void 0 : _a3.querySelector(
-      "a[data-block-id][data-parameters]"
-    );
-    const block_id = (parametersElement == null ? void 0 : parametersElement.getAttribute("data-block-id")) || "";
-    const parameters = parseDataParams(
-      (parametersElement == null ? void 0 : parametersElement.getAttribute("data-parameters")) || ""
-    );
-    const attrs = {
-      block_id,
-      function: "get_block",
-      mode: "async",
-      ...parameters
-    };
-    Object.keys(attrs).forEach((k2) => {
-      url.searchParams.set(k2, attrs[k2]);
-    });
-    const paginationUrlGenerator = (n) => {
-      Object.keys(attrs).forEach((k2) => {
-        k2.includes("from") && url.searchParams.set(k2, n.toString());
-      });
-      url.searchParams.set("_", Date.now().toString());
-      return url.href;
-    };
-    return paginationUrlGenerator;
-  }
-  static testLinks(doc = document) {
-    const dataParamLinks = Array.from(
-      doc.querySelectorAll("[data-parameters *= from]")
-    );
-    return dataParamLinks.length > 0;
-  }
-}
 class PaginationStrategyPathnameParams extends PaginationStrategy {
   constructor() {
     super(...arguments);
@@ -1733,6 +2372,156 @@ function getPaginationStrategy(options) {
   const paginationStrategy = new PaginationStrategyConstructor(options);
   return paginationStrategy;
 }
+class ThumbDataParser {
+  constructor(strategy = "manual", selectors = {}, callback, stringsMeltInTitle = true) {
+    __publicField(this, "thumbDataSelectors", []);
+    __publicField(this, "defaultThumbDataSelectors", [
+      { name: "title", type: "string", selector: "[class *= title],[title]" },
+      {
+        name: "uploader",
+        type: "string",
+        selector: "[class *= uploader], [class *= user], [class *= name]"
+      },
+      { name: "duration", type: "duration", selector: "[class *= duration]" }
+    ]);
+    this.strategy = strategy;
+    this.selectors = selectors;
+    this.callback = callback;
+    this.stringsMeltInTitle = stringsMeltInTitle;
+    this.preprocessCustomThumbDataSelectors();
+  }
+  autoParseText(thumb) {
+    var _a3;
+    const title = sanitizeStr(thumb.innerText);
+    const duration = timeToSeconds(((_a3 = title.match(/\d+m|\d+:\d+/)) == null ? void 0 : _a3[0]) || "");
+    return { title, duration };
+  }
+  preprocessCustomThumbDataSelectors() {
+    if (!this.selectors) return;
+    Object.entries(this.selectors).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        const defaultSelector = this.defaultThumbDataSelectors.find((e) => e.name === key);
+        if (!defaultSelector) {
+          this.thumbDataSelectors.push({ name: key, selector: value, type: "string" });
+        } else {
+          defaultSelector.selector = value;
+          this.thumbDataSelectors.push(defaultSelector);
+        }
+      } else {
+        this.thumbDataSelectors.push({ name: key, ...value });
+      }
+    });
+  }
+  getThumbDataWith(thumb, { type, selector }) {
+    var _a3;
+    if (type === "boolean") {
+      return !!thumb.querySelector(selector);
+    }
+    if (type === "string") {
+      return sanitizeStr(((_a3 = querySelectorLast(thumb, selector)) == null ? void 0 : _a3.innerText) || "");
+    }
+    if (type === "duration") {
+      return timeToSeconds(querySelectorText(thumb, selector));
+    }
+    return Number.parseInt(querySelectorText(thumb, selector));
+  }
+  static create(o = {}) {
+    return new ThumbDataParser(o.strategy, o.selectors, o.callback, o.stringsMeltInTitle);
+  }
+  getThumbData(thumb) {
+    var _a3;
+    if (this.strategy === "auto-text") {
+      return this.autoParseText(thumb);
+    }
+    if (this.strategy === "auto-select") {
+      this.thumbDataSelectors = this.defaultThumbDataSelectors;
+    }
+    const thumbData = Object.fromEntries(
+      this.thumbDataSelectors.map((s) => [s.name, this.getThumbDataWith(thumb, s)])
+    );
+    if (this.stringsMeltInTitle) {
+      Object.entries(thumbData).forEach(([k2, v2]) => {
+        if (typeof v2 === "string" && k2 !== "title") {
+          thumbData.title = `${thumbData.title} ${k2}:${v2}`;
+          delete thumbData[k2];
+        }
+      });
+    }
+    (_a3 = this.callback) == null ? void 0 : _a3.call(this, thumb, thumbData);
+    return thumbData;
+  }
+}
+class ThumbImgParser {
+  constructor() {
+    __publicField(this, "selector");
+    __publicField(this, "remove");
+    __publicField(this, "strategy", "default");
+  }
+  static create(options = {}) {
+    return Object.assign(new ThumbImgParser(), options);
+  }
+  removeAttrs(img) {
+    if (!this.remove) return;
+    if (this.remove === "auto") {
+      removeClassesAndDataAttributes(img, "lazy");
+    } else {
+      if (this.remove.startsWith(".")) {
+        img.classList.remove(this.remove.slice(1));
+      } else {
+        img.removeAttribute(this.remove);
+      }
+    }
+  }
+  getImgSrc(img) {
+    const possibleAttrs = this.selector ? [this.selector].flat() : ["data-src", "src"];
+    for (const attr of possibleAttrs) {
+      const imgSrc = img.getAttribute(attr);
+      if (imgSrc) {
+        return imgSrc;
+      }
+    }
+    return "";
+  }
+  getImgData(thumb) {
+    if (this.strategy === "default" && !this.selector) return {};
+    const img = thumb.querySelector("img");
+    if (!img) return {};
+    const imgSrc = typeof this.selector === "function" ? this.selector(img) : this.getImgSrc(img);
+    this.removeAttrs(img);
+    if (img.src.includes("data:image")) {
+      img.src = "";
+    }
+    if (img.complete && img.naturalWidth > 0) {
+      return {};
+    }
+    return { img, imgSrc };
+  }
+}
+class ThumbsParser {
+  constructor(containerSelector) {
+    __publicField(this, "selector", ".thumb");
+    __publicField(this, "strategy", "default");
+    __publicField(this, "transform");
+    this.containerSelector = containerSelector;
+  }
+  static create(options = {}, containerSelector) {
+    return Object.assign(new ThumbsParser(containerSelector), options);
+  }
+  getThumbs(html) {
+    if (!html) return [];
+    let thumbs;
+    if (this.strategy === "auto") {
+      if (typeof this.selector !== "string") return [];
+      const container = html.querySelector(this.containerSelector);
+      thumbs = [...(container == null ? void 0 : container.children) || []];
+    }
+    thumbs = Array.from(html.querySelectorAll(this.selector));
+    if (typeof this.transform === "function") {
+      thumbs.forEach(this.transform);
+    }
+    return thumbs;
+  }
+}
 var xi = {};
 // @__NO_SIDE_EFFECTS__
 function oe(t) {
@@ -8286,27 +9075,21 @@ const StoreStateDefault = {
   $paginationLast: 1,
   $paginationOffset: 1
 };
-class RulesGlobal {
+class Rules {
   constructor(options) {
-    __publicField(this, "delay");
-    __publicField(this, "customGenerator");
-    __publicField(this, "titleSelector");
-    __publicField(this, "uploaderSelector");
-    __publicField(this, "durationSelector");
-    __publicField(this, "customThumbDataSelectors");
-    __publicField(this, "getThumbDataStrategy", "default");
-    __publicField(this, "getThumbDataCallback");
-    __publicField(this, "getThumbImgDataAttrSelector");
-    __publicField(this, "getThumbImgDataAttrDelete");
-    __publicField(this, "getThumbImgDataStrategy", "default");
+    __publicField(this, "thumb", {});
+    __publicField(this, "thumbDataParser");
+    __publicField(this, "thumbImg", {});
+    __publicField(this, "thumbImgParser");
+    __publicField(this, "thumbs", {});
+    __publicField(this, "thumbsParser");
     __publicField(this, "containerSelector", ".container");
     __publicField(this, "containerSelectorLast");
     __publicField(this, "intersectionObservableSelector");
-    __publicField(this, "thumbsSelector", ".thumb");
-    __publicField(this, "getThumbsStrategy", "default");
-    __publicField(this, "getThumbsTransform");
     __publicField(this, "paginationStrategyOptions", {});
     __publicField(this, "paginationStrategy");
+    __publicField(this, "dataManager");
+    __publicField(this, "dataHomogenity");
     __publicField(this, "customDataSelectorFns", [
       "filterInclude",
       "filterExclude",
@@ -8317,121 +9100,27 @@ class RulesGlobal {
     __publicField(this, "schemeOptions", []);
     __publicField(this, "store");
     __publicField(this, "gui");
-    __publicField(this, "dataManager");
+    __publicField(this, "customGenerator");
     __publicField(this, "infiniteScroller");
     __publicField(this, "getPaginationData");
     __publicField(this, "gropeStrategy", "all-in-one");
-    __publicField(this, "dataManagerOptions", {});
     __publicField(this, "mutationObservers", []);
     __publicField(this, "resetOnPaginationOrContainerDeath", true);
     __publicField(this, "onResetCallback");
     if (this.isEmbedded) throw Error("Embedded is not supported");
     Object.assign(this, options);
+    this.thumbDataParser = ThumbDataParser.create(this.thumb);
+    this.thumbImgParser = ThumbImgParser.create(this.thumbImg);
+    this.thumbsParser = ThumbsParser.create(this.thumbs, this.containerSelector);
     this.paginationStrategy = getPaginationStrategy(this.paginationStrategyOptions);
     this.store = this.createStore();
     this.gui = this.createGui();
-    this.dataManager = this.setupDataManager();
+    this.dataManager = new DataManager(this, this.dataHomogenity);
     this.reset();
   }
   getThumbUrl(thumb) {
     return (thumb.querySelector("a[href]") || thumb).href;
   }
-  getThumbData(thumb) {
-    var _a3, _b2;
-    let { titleSelector, uploaderSelector, durationSelector } = this;
-    const thumbData = { title: "" };
-    if (this.getThumbDataStrategy === "auto-text") {
-      const text = sanitizeStr(thumb.innerText);
-      thumbData.title = text;
-      thumbData.duration = timeToSeconds(((_a3 = text.match(/\d+m|\d+:\d+/)) == null ? void 0 : _a3[0]) || "");
-      return thumbData;
-    }
-    if (this.getThumbDataStrategy === "auto-select") {
-      titleSelector = "[class *= title],[title]";
-      durationSelector = "[class *= duration]";
-      uploaderSelector = "[class *= uploader], [class *= user], [class *= name]";
-    }
-    if (this.getThumbDataStrategy === "auto-select") {
-      const selected = querySelectorLast(thumb, titleSelector);
-      if (selected) {
-        thumbData.title = sanitizeStr(selected.innerText);
-      } else {
-        thumbData.title = sanitizeStr(thumb.innerText);
-      }
-    } else {
-      thumbData.title = querySelectorText(thumb, titleSelector);
-    }
-    if (uploaderSelector) {
-      const uploader = querySelectorText(thumb, uploaderSelector);
-      thumbData.title = `${thumbData.title} user:${uploader}`;
-    }
-    if (durationSelector) {
-      const duration = timeToSeconds(querySelectorText(thumb, durationSelector));
-      thumbData.duration = duration;
-    }
-    (_b2 = this.getThumbDataCallback) == null ? void 0 : _b2.call(this, thumb, thumbData);
-    function getCustomThumbData(selector, type) {
-      if (type === "boolean") {
-        return !!thumb.querySelector(selector);
-      }
-      if (type === "string") {
-        return querySelectorText(thumb, selector);
-      }
-      return Number.parseInt(querySelectorText(thumb, selector));
-    }
-    if (this.customThumbDataSelectors) {
-      Object.entries(this.customThumbDataSelectors).forEach(([name, x2]) => {
-        const data = getCustomThumbData(x2.selector, x2.type);
-        Object.assign(thumbData, { [name]: data });
-      });
-    }
-    return thumbData;
-  }
-  getThumbImgData(thumb) {
-    const result = {};
-    if (this.getThumbImgDataStrategy === "auto") {
-      const img = thumb.querySelector("img");
-      if (!img) return {};
-      result.img = img;
-      if (typeof this.getThumbImgDataAttrSelector === "function") {
-        result.imgSrc = this.getThumbImgDataAttrSelector(img);
-      } else {
-        const possibleAttrs = this.getThumbImgDataAttrSelector ? [this.getThumbImgDataAttrSelector].flat() : ["data-src", "src"];
-        for (const attr of possibleAttrs) {
-          const imgSrc = img.getAttribute(attr);
-          if (imgSrc) {
-            result.imgSrc = imgSrc;
-            img.removeAttribute(attr);
-            break;
-          }
-        }
-      }
-      if (this.getThumbImgDataAttrDelete) {
-        if (this.getThumbImgDataAttrDelete === "auto") {
-          removeClassesAndDataAttributes(img, "lazy");
-        } else {
-          if (this.getThumbImgDataAttrDelete.startsWith(".")) {
-            img.classList.remove(this.getThumbImgDataAttrDelete.slice(1));
-          } else {
-            img.removeAttribute(this.getThumbImgDataAttrDelete);
-          }
-        }
-        if (img.src.includes("data:image")) {
-          result.img.src = "";
-        }
-        if (img.complete && img.naturalWidth > 0) {
-          return {};
-        }
-      }
-    }
-    return result;
-  }
-  get intersectionObservable() {
-    return this.intersectionObservableSelector && document.querySelector(this.intersectionObservableSelector);
-  }
-  get observable() {
-    return this.intersectionObservable || this.paginationStrategy.getPaginationElement();
-  }
   get container() {
     if (typeof this.containerSelectorLast === "string") {
       return querySelectorLast(document, this.containerSelectorLast);
@@ -8441,23 +9130,15 @@ class RulesGlobal {
     }
     return this.containerSelector();
   }
-  getThumbs(html) {
-    if (!html) return [];
-    let thumbs;
-    if (this.getThumbsStrategy === "auto") {
-      if (typeof this.containerSelector !== "string") return [];
-      const container = html.querySelector(this.containerSelector);
-      thumbs = [...(container == null ? void 0 : container.children) || []];
-    }
-    thumbs = Array.from(html.querySelectorAll(this.thumbsSelector));
-    if (typeof this.getThumbsTransform === "function") {
-      thumbs.forEach(this.getThumbsTransform);
-    }
-    return thumbs;
+  get intersectionObservable() {
+    return this.intersectionObservableSelector && document.querySelector(this.intersectionObservableSelector);
+  }
+  get observable() {
+    return this.intersectionObservable || this.paginationStrategy.getPaginationElement();
   }
   createStore() {
-    const config = { ...StoreStateDefault, ...this.storeOptions };
-    this.store = new Up(config);
+    const config2 = { ...StoreStateDefault, ...this.storeOptions };
+    this.store = new Up(config2);
     return this.store;
   }
   createGui() {
@@ -8481,7 +9162,7 @@ class RulesGlobal {
       (_a3 = this.dataManager) == null ? void 0 : _a3.parseData(this.container, this.container);
     }
     if (this.gropeStrategy === "all-in-all") {
-      getCommonParents(this.getThumbs(document.body)).forEach((c) => {
+      getCommonParents(this.thumbsParser.getThumbs(document.body)).forEach((c) => {
         this.dataManager.parseData(c, c, true);
       });
     }
@@ -8513,13 +9194,6 @@ class RulesGlobal {
       this.dataManager.applyFilters(a2);
     });
   }
-  setupDataManager() {
-    this.dataManager = new DataManager(this);
-    if (this.dataManagerOptions) {
-      Object.assign(this.dataManager, this.dataManagerOptions);
-    }
-    return this.dataManager;
-  }
   resetOn() {
     if (!this.resetOnPaginationOrContainerDeath) return;
     const observables = [
@@ -8541,7 +9215,7 @@ class RulesGlobal {
     });
     this.mutationObservers = [];
     this.paginationStrategy = getPaginationStrategy(this.paginationStrategyOptions);
-    this.setupDataManager();
+    this.dataManager = new DataManager(this, this.dataHomogenity);
     this.setupStoreListeners();
     this.resetInfiniteScroller();
     this.container && ((_a3 = this.animatePreview) == null ? void 0 : _a3.call(this, this.container));
@@ -8551,13 +9225,22 @@ class RulesGlobal {
   }
 }
 export {
+  DataFilter,
   DataManager,
   InfiniteScroller,
   LazyImgLoader,
+  MOBILE_UA,
   Observer,
   OnHover,
+  PaginationStrategy,
+  PaginationStrategyDataParams,
+  PaginationStrategyPathnameParams,
+  PaginationStrategySearchParams,
   RegexFilter,
-  RulesGlobal,
+  Rules,
+  ThumbDataParser,
+  ThumbImgParser,
+  ThumbsParser,
   Tick,
   checkHomogenity,
   chunks,
@@ -8570,6 +9253,7 @@ export {
   fetchText,
   fetchWith,
   findNextSibling,
+  formatTimeToHHMMSS,
   getCommonParents,
   getPaginationStrategy,
   instantiateTemplate,
@@ -8579,6 +9263,7 @@ export {
   parseDataParams,
   parseHtml,
   parseIntegerOr,
+  parseUrl,
   querySelectorLast,
   querySelectorLastNumber,
   querySelectorText,