☰

Iwara Custom Sort

Automatically sort teaser images on /videos, /images, /subscriptions, /users, /playlist, and sidebars using customizable sort function. Can load and sort multiple pages at once.

  1. // ==UserScript==
  2. // @name           Iwara Custom Sort
  3. // @version        1.1.0
  4. // @description    Automatically sort teaser images on /videos, /images, /subscriptions, /users, /playlist, and sidebars using customizable sort function. Can load and sort multiple pages at once.
  5. // @match          http://ecchi.iwara.tv/*
  6. // @match          https://ecchi.iwara.tv/*
  7. // @match          http://www.iwara.tv/*
  8. // @match          https://www.iwara.tv/*
  9. // @name:ja        Iwara Custom ソート
  10. // @run-at         document-end
  11. // @grant          GM.setValue
  12. // @grant          GM.getValue
  13. // @grant          GM.deleteValue
  14. // @grant          GM.listValues
  15. // @license        AGPL-3.0-or-later
  16. // @description:ja /videos、/images、/subscriptions、/users、/playlistとサイドバーのサムネイルを自動的にソートします。ソート方法はカスタマイズすることができます、一度に複数のページを読み込んでソートすることができます。
  17. // @require        https://cdn.jsdelivr.net/npm/sweetalert2@11.0.18/dist/sweetalert2.all.min.js#sha384-EoPspU1QiQ0II6WaHKy5pERCBPBD1VqZByJ29O7fDUJxGXwWLyEREDpvym8c4v2S
  18. // @require        https://unpkg.com/loglevel@1.7.0/dist/loglevel.min.js#sha384-7gGuWfek8Ql6j/uNDFrS0BCe4x2ZihD4B68w9Eu580OVHJBV+bl3rZmEWC7q5/Gj
  19. // @require        https://unpkg.com/rxjs@7.3.0/dist/bundles/rxjs.umd.min.js#sha384-B2HMABdZA26zJ9QwbG/c5zrcdr6+Zs8J4MgKs7udycjXgvRDA5nZKLzJ1vXWzJyH
  20. // @require        https://unpkg.com/mithril@2.0.4/mithril.min.js#sha384-vo9crXih40MlEv6JWHqS7SsPiFp+76csaWQFOF2UU0/xI58Jm/ZvK/1UtpaicJT9
  21. // @namespace      https://gf.qytechs.cn/users/245195
  22. // ==/UserScript==
  23.  
  24. /* jshint esversion: 6 */
  25.  
  26. ;(() => {
  27.   var __webpack_modules__ = {
  28.       494: function (module, exports, __webpack_require__) {
  29.         var __WEBPACK_AMD_DEFINE_RESULT__
  30.         !(function (globals) {
  31.           "use strict"
  32.           var messages,
  33.             predicates,
  34.             functions,
  35.             assert,
  36.             not,
  37.             maybe,
  38.             collections,
  39.             hasOwnProperty,
  40.             toString,
  41.             keys,
  42.             slice,
  43.             isArray,
  44.             neginf,
  45.             posinf,
  46.             haveSymbols,
  47.             haveMaps,
  48.             haveSets
  49.           function assigned(data) {
  50.             return null != data
  51.           }
  52.           function number(data) {
  53.             return "number" == typeof data && data > neginf && data < posinf
  54.           }
  55.           function integer(data) {
  56.             return "number" == typeof data && data % 1 == 0
  57.           }
  58.           function greater(lhs, rhs) {
  59.             return number(lhs) && lhs > rhs
  60.           }
  61.           function less(lhs, rhs) {
  62.             return number(lhs) && lhs < rhs
  63.           }
  64.           function greaterOrEqual(lhs, rhs) {
  65.             return number(lhs) && lhs >= rhs
  66.           }
  67.           function lessOrEqual(lhs, rhs) {
  68.             return number(lhs) && lhs <= rhs
  69.           }
  70.           function string(data) {
  71.             return "string" == typeof data
  72.           }
  73.           function nonEmptyString(data) {
  74.             return string(data) && "" !== data
  75.           }
  76.           function object(data) {
  77.             return "[object Object]" === toString.call(data)
  78.           }
  79.           function some(data, predicate) {
  80.             for (var key in data)
  81.               if (hasOwnProperty.call(data, key) && predicate(key, data[key]))
  82.                 return !0
  83.             return !1
  84.           }
  85.           function instanceStrict(data, prototype) {
  86.             try {
  87.               return data instanceof prototype
  88.             } catch (error) {
  89.               return !1
  90.             }
  91.           }
  92.           function like(data, archetype) {
  93.             var name
  94.             for (name in archetype)
  95.               if (hasOwnProperty.call(archetype, name)) {
  96.                 if (
  97.                   !1 === hasOwnProperty.call(data, name) ||
  98.                   typeof data[name] != typeof archetype[name]
  99.                 )
  100.                   return !1
  101.                 if (
  102.                   object(data[name]) &&
  103.                   !1 === like(data[name], archetype[name])
  104.                 )
  105.                   return !1
  106.               }
  107.             return !0
  108.           }
  109.           function arrayLike(data) {
  110.             return assigned(data) && data.length >= 0
  111.           }
  112.           function iterable(data) {
  113.             return haveSymbols
  114.               ? assigned(data) && isFunction(data[Symbol.iterator])
  115.               : arrayLike(data)
  116.           }
  117.           function contains(data, value) {
  118.             var iterator, iteration
  119.             if (!assigned(data)) return !1
  120.             if (haveSets && instanceStrict(data, Set)) return data.has(value)
  121.             if (string(data)) return -1 !== data.indexOf(value)
  122.             if (
  123.               haveSymbols &&
  124.               data[Symbol.iterator] &&
  125.               isFunction(data.values)
  126.             ) {
  127.               iterator = data.values()
  128.               do {
  129.                 if ((iteration = iterator.next()).value === value) return !0
  130.               } while (!iteration.done)
  131.               return !1
  132.             }
  133.             return some(data, function (key, dataValue) {
  134.               return dataValue === value
  135.             })
  136.           }
  137.           function containsKey(data, key) {
  138.             return (
  139.               !!assigned(data) &&
  140.               (haveMaps && instanceStrict(data, Map)
  141.                 ? data.has(key)
  142.                 : !(iterable(data) && !number(+key)) && !!data[key])
  143.             )
  144.           }
  145.           function isFunction(data) {
  146.             return "function" == typeof data
  147.           }
  148.           function forEach(object, action) {
  149.             for (var key in object)
  150.               hasOwnProperty.call(object, key) && action(key, object[key])
  151.           }
  152.           function testArray(data, result) {
  153.             var i
  154.             for (i = 0; i < data.length; i += 1)
  155.               if (data[i] === result) return result
  156.             return !result
  157.           }
  158.           function testObject(data, result) {
  159.             var key, value
  160.             for (key in data)
  161.               if (hasOwnProperty.call(data, key)) {
  162.                 if (
  163.                   object((value = data[key])) &&
  164.                   testObject(value, result) === result
  165.                 )
  166.                   return result
  167.                 if (value === result) return result
  168.               }
  169.             return !result
  170.           }
  171.           function mixin(target, source) {
  172.             return (
  173.               forEach(source, function (key, value) {
  174.                 target[key] = value
  175.               }),
  176.               target
  177.             )
  178.           }
  179.           function assertModifier(predicate, defaultMessage) {
  180.             return function () {
  181.               var args = arguments,
  182.                 argCount = predicate.l || predicate.length,
  183.                 message = args[argCount],
  184.                 ErrorType = args[argCount + 1]
  185.               return (
  186.                 assertImpl(
  187.                   predicate.apply(null, args),
  188.                   nonEmptyString(message)
  189.                     ? message
  190.                     : defaultMessage
  191.                         .replace("{a}", messageFormatter(args[0]))
  192.                         .replace("{e}", messageFormatter(args[1]))
  193.                         .replace("{e2}", messageFormatter(args[2]))
  194.                         .replace("{t}", function () {
  195.                           var arg = args[1]
  196.                           return arg && arg.name ? arg.name : arg
  197.                         }),
  198.                   isFunction(ErrorType) ? ErrorType : TypeError
  199.                 ),
  200.                 args[0]
  201.               )
  202.             }
  203.           }
  204.           function messageFormatter(arg) {
  205.             return function () {
  206.               return string(arg)
  207.                 ? '"' + arg.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"'
  208.                 : arg &&
  209.                   !0 !== arg &&
  210.                   arg.constructor &&
  211.                   !instanceStrict(arg, RegExp) &&
  212.                   "number" != typeof arg
  213.                 ? arg.constructor.name
  214.                 : arg
  215.             }
  216.           }
  217.           function assertImpl(value, message, ErrorType) {
  218.             if (value) return value
  219.             throw new (ErrorType || Error)(message || "assert failed")
  220.           }
  221.           function notModifier(predicate) {
  222.             var modifiedPredicate = function () {
  223.               return notImpl(predicate.apply(null, arguments))
  224.             }
  225.             return (modifiedPredicate.l = predicate.length), modifiedPredicate
  226.           }
  227.           function notImpl(value) {
  228.             return !value
  229.           }
  230.           function ofModifier(target, type, predicate) {
  231.             var modifiedPredicate = function () {
  232.               var collection, args
  233.               if (
  234.                 ((collection = arguments[0]),
  235.                 "maybe" === target && not.assigned(collection))
  236.               )
  237.                 return !0
  238.               if (!type(collection)) return !1
  239.               ;(collection = coerceCollection(type, collection)),
  240.                 (args = slice.call(arguments, 1))
  241.               try {
  242.                 collection.forEach(function (item) {
  243.                   if (
  244.                     ("maybe" !== target || assigned(item)) &&
  245.                     !predicate.apply(null, [item].concat(args))
  246.                   )
  247.                     throw 0
  248.                 })
  249.               } catch (ignore) {
  250.                 return !1
  251.               }
  252.               return !0
  253.             }
  254.             return (modifiedPredicate.l = predicate.length), modifiedPredicate
  255.           }
  256.           function coerceCollection(type, collection) {
  257.             switch (type) {
  258.               case arrayLike:
  259.                 return slice.call(collection)
  260.               case object:
  261.                 return keys(collection).map(function (key) {
  262.                   return collection[key]
  263.                 })
  264.               default:
  265.                 return collection
  266.             }
  267.           }
  268.           function createModifiedPredicates(modifier, object) {
  269.             return createModifiedFunctions([modifier, predicates, object, ""])
  270.           }
  271.           function createModifiedFunctions(args) {
  272.             var modifier, messageModifier, object
  273.             return (
  274.               (modifier = args.shift()),
  275.               (messageModifier = args.pop()),
  276.               (object = args.pop()),
  277.               forEach(args.pop(), function (key, fn) {
  278.                 var message = messages[key]
  279.                 message &&
  280.                   messageModifier &&
  281.                   (message = message.replace("to", messageModifier + "to")),
  282.                   Object.defineProperty(object, key, {
  283.                     configurable: !1,
  284.                     enumerable: !0,
  285.                     writable: !1,
  286.                     value: modifier.apply(null, args.concat(fn, message)),
  287.                   })
  288.               }),
  289.               object
  290.             )
  291.           }
  292.           function createModifiedModifier(modifier, modified, messageModifier) {
  293.             return createModifiedFunctions([
  294.               modifier,
  295.               modified,
  296.               {},
  297.               messageModifier,
  298.             ])
  299.           }
  300.           function createOfModifiers(base, modifier) {
  301.             collections.forEach(function (key) {
  302.               base[key].of = createModifiedModifier(
  303.                 modifier,
  304.                 predicates[key].of
  305.               )
  306.             })
  307.           }
  308.           ;(messages = {}),
  309.             (predicates = {}),
  310.             [
  311.               {
  312.                 n: "equal",
  313.                 f: function (lhs, rhs) {
  314.                   return lhs === rhs
  315.                 },
  316.                 s: "equal {e}",
  317.               },
  318.               {
  319.                 n: "undefined",
  320.                 f: function (data) {
  321.                   return void 0 === data
  322.                 },
  323.                 s: "be undefined",
  324.               },
  325.               {
  326.                 n: "null",
  327.                 f: function (data) {
  328.                   return null === data
  329.                 },
  330.                 s: "be null",
  331.               },
  332.               { n: "assigned", f: assigned, s: "be assigned" },
  333.               {
  334.                 n: "primitive",
  335.                 f: function (data) {
  336.                   var type
  337.                   switch (data) {
  338.                     case null:
  339.                     case void 0:
  340.                     case !1:
  341.                     case !0:
  342.                       return !0
  343.                   }
  344.                   return (
  345.                     "string" === (type = typeof data) ||
  346.                     "number" === type ||
  347.                     (haveSymbols && "symbol" === type)
  348.                   )
  349.                 },
  350.                 s: "be primitive type",
  351.               },
  352.               { n: "contains", f: contains, s: "contain {e}" },
  353.               {
  354.                 n: "in",
  355.                 f: function (value, data) {
  356.                   return contains(data, value)
  357.                 },
  358.                 s: "be in {e}",
  359.               },
  360.               { n: "containsKey", f: containsKey, s: "contain key {e}" },
  361.               {
  362.                 n: "keyIn",
  363.                 f: function (key, data) {
  364.                   return containsKey(data, key)
  365.                 },
  366.                 s: "be key in {e}",
  367.               },
  368.               {
  369.                 n: "zero",
  370.                 f: function (data) {
  371.                   return 0 === data
  372.                 },
  373.                 s: "be 0",
  374.               },
  375.               {
  376.                 n: "one",
  377.                 f: function (data) {
  378.                   return 1 === data
  379.                 },
  380.                 s: "be 1",
  381.               },
  382.               {
  383.                 n: "infinity",
  384.                 f: function (data) {
  385.                   return data === neginf || data === posinf
  386.                 },
  387.                 s: "be infinity",
  388.               },
  389.               { n: "number", f: number, s: "be Number" },
  390.               { n: "integer", f: integer, s: "be integer" },
  391.               {
  392.                 n: "float",
  393.                 f: function (data) {
  394.                   return number(data) && data % 1 != 0
  395.                 },
  396.                 s: "be non-integer number",
  397.               },
  398.               {
  399.                 n: "even",
  400.                 f: function (data) {
  401.                   return "number" == typeof data && data % 2 == 0
  402.                 },
  403.                 s: "be even number",
  404.               },
  405.               {
  406.                 n: "odd",
  407.                 f: function (data) {
  408.                   return integer(data) && data % 2 != 0
  409.                 },
  410.                 s: "be odd number",
  411.               },
  412.               { n: "greater", f: greater, s: "be greater than {e}" },
  413.               { n: "less", f: less, s: "be less than {e}" },
  414.               {
  415.                 n: "between",
  416.                 f: function (data, x, y) {
  417.                   if (x < y) return greater(data, x) && data < y
  418.                   return less(data, x) && data > y
  419.                 },
  420.                 s: "be between {e} and {e2}",
  421.               },
  422.               {
  423.                 n: "greaterOrEqual",
  424.                 f: greaterOrEqual,
  425.                 s: "be greater than or equal to {e}",
  426.               },
  427.               {
  428.                 n: "lessOrEqual",
  429.                 f: lessOrEqual,
  430.                 s: "be less than or equal to {e}",
  431.               },
  432.               {
  433.                 n: "inRange",
  434.                 f: function (data, x, y) {
  435.                   if (x < y) return greaterOrEqual(data, x) && data <= y
  436.                   return lessOrEqual(data, x) && data >= y
  437.                 },
  438.                 s: "be in the range {e} to {e2}",
  439.               },
  440.               {
  441.                 n: "positive",
  442.                 f: function (data) {
  443.                   return greater(data, 0)
  444.                 },
  445.                 s: "be positive number",
  446.               },
  447.               {
  448.                 n: "negative",
  449.                 f: function (data) {
  450.                   return less(data, 0)
  451.                 },
  452.                 s: "be negative number",
  453.               },
  454.               { n: "string", f: string, s: "be String" },
  455.               {
  456.                 n: "emptyString",
  457.                 f: function (data) {
  458.                   return "" === data
  459.                 },
  460.                 s: "be empty string",
  461.               },
  462.               {
  463.                 n: "nonEmptyString",
  464.                 f: nonEmptyString,
  465.                 s: "be non-empty string",
  466.               },
  467.               {
  468.                 n: "match",
  469.                 f: function (data, regex) {
  470.                   return string(data) && !!data.match(regex)
  471.                 },
  472.                 s: "match {e}",
  473.               },
  474.               {
  475.                 n: "boolean",
  476.                 f: function (data) {
  477.                   return !1 === data || !0 === data
  478.                 },
  479.                 s: "be Boolean",
  480.               },
  481.               { n: "object", f: object, s: "be Object" },
  482.               {
  483.                 n: "emptyObject",
  484.                 f: function (data) {
  485.                   return (
  486.                     object(data) &&
  487.                     !some(data, function () {
  488.                       return !0
  489.                     })
  490.                   )
  491.                 },
  492.                 s: "be empty object",
  493.               },
  494.               {
  495.                 n: "nonEmptyObject",
  496.                 f: function (data) {
  497.                   return (
  498.                     object(data) &&
  499.                     some(data, function () {
  500.                       return !0
  501.                     })
  502.                   )
  503.                 },
  504.                 s: "be non-empty object",
  505.               },
  506.               {
  507.                 n: "instanceStrict",
  508.                 f: instanceStrict,
  509.                 s: "be instanceof {t}",
  510.               },
  511.               {
  512.                 n: "thenable",
  513.                 f: function (data) {
  514.                   return assigned(data) && isFunction(data.then)
  515.                 },
  516.                 s: "be promise-like",
  517.               },
  518.               {
  519.                 n: "instance",
  520.                 f: function (data, prototype) {
  521.                   try {
  522.                     return (
  523.                       instanceStrict(data, prototype) ||
  524.                       data.constructor.name === prototype.name ||
  525.                       toString.call(data) === "[object " + prototype.name + "]"
  526.                     )
  527.                   } catch (error) {
  528.                     return !1
  529.                   }
  530.                 },
  531.                 s: "be {t}",
  532.               },
  533.               { n: "like", f: like, s: "be like {e}" },
  534.               {
  535.                 n: "array",
  536.                 f: function (data) {
  537.                   return isArray(data)
  538.                 },
  539.                 s: "be Array",
  540.               },
  541.               {
  542.                 n: "emptyArray",
  543.                 f: function (data) {
  544.                   return isArray(data) && 0 === data.length
  545.                 },
  546.                 s: "be empty array",
  547.               },
  548.               {
  549.                 n: "nonEmptyArray",
  550.                 f: function (data) {
  551.                   return isArray(data) && data.length > 0
  552.                 },
  553.                 s: "be non-empty array",
  554.               },
  555.               { n: "arrayLike", f: arrayLike, s: "be array-like" },
  556.               { n: "iterable", f: iterable, s: "be iterable" },
  557.               {
  558.                 n: "date",
  559.                 f: function (data) {
  560.                   return instanceStrict(data, Date) && integer(data.getTime())
  561.                 },
  562.                 s: "be valid Date",
  563.               },
  564.               { n: "function", f: isFunction, s: "be Function" },
  565.               {
  566.                 n: "hasLength",
  567.                 f: function (data, length) {
  568.                   return assigned(data) && data.length === length
  569.                 },
  570.                 s: "have length {e}",
  571.               },
  572.               {
  573.                 n: "throws",
  574.                 f: function (data) {
  575.                   if (!isFunction(data)) return !1
  576.                   try {
  577.                     data()
  578.                   } catch (error) {
  579.                     return !0
  580.                   }
  581.                   return !1
  582.                 },
  583.                 s: "throw",
  584.               },
  585.             ].map(function (data) {
  586.               var n = data.n
  587.               ;(messages[n] = "assert failed: expected {a} to " + data.s),
  588.                 (predicates[n] = data.f)
  589.             }),
  590.             (functions = {
  591.               map: function map(data, predicates) {
  592.                 var result
  593.                 result = isArray(data) ? [] : {}
  594.                 if (isFunction(predicates))
  595.                   forEach(data, function (key, value) {
  596.                     result[key] = predicates(value)
  597.                   })
  598.                 else {
  599.                   isArray(predicates) || assert.object(predicates)
  600.                   var dataKeys = keys(data || {})
  601.                   forEach(predicates, function (key, predicate) {
  602.                     dataKeys.some(function (dataKey, index) {
  603.                       return dataKey === key && (dataKeys.splice(index, 1), !0)
  604.                     }),
  605.                       isFunction(predicate)
  606.                         ? not.assigned(data)
  607.                           ? (result[key] = !!predicate.m)
  608.                           : (result[key] = predicate(data[key]))
  609.                         : (result[key] = map(data[key], predicate))
  610.                   })
  611.                 }
  612.                 return result
  613.               },
  614.               all: function (data) {
  615.                 if (isArray(data)) return testArray(data, !1)
  616.                 return assert.object(data), testObject(data, !1)
  617.               },
  618.               any: function (data) {
  619.                 if (isArray(data)) return testArray(data, !0)
  620.                 return assert.object(data), testObject(data, !0)
  621.               },
  622.             }),
  623.             (collections = ["array", "arrayLike", "iterable", "object"]),
  624.             (hasOwnProperty = Object.prototype.hasOwnProperty),
  625.             (toString = Object.prototype.toString),
  626.             (keys = Object.keys),
  627.             (slice = Array.prototype.slice),
  628.             (isArray = Array.isArray),
  629.             (neginf = Number.NEGATIVE_INFINITY),
  630.             (posinf = Number.POSITIVE_INFINITY),
  631.             (haveSymbols = "function" == typeof Symbol),
  632.             (haveMaps = "function" == typeof Map),
  633.             (haveSets = "function" == typeof Set),
  634.             (functions = mixin(functions, predicates)),
  635.             (assert = createModifiedPredicates(assertModifier, assertImpl)),
  636.             (not = createModifiedPredicates(notModifier, notImpl)),
  637.             (maybe = createModifiedPredicates(
  638.               function (predicate) {
  639.                 var modifiedPredicate = function () {
  640.                   return (
  641.                     !!not.assigned(arguments[0]) ||
  642.                     predicate.apply(null, arguments)
  643.                   )
  644.                 }
  645.                 return (
  646.                   (modifiedPredicate.l = predicate.length),
  647.                   (modifiedPredicate.m = !0),
  648.                   modifiedPredicate
  649.                 )
  650.               },
  651.               function (value) {
  652.                 if (!1 === assigned(value)) return !0
  653.                 return value
  654.               }
  655.             )),
  656.             (assert.not = createModifiedModifier(assertModifier, not, "not ")),
  657.             (assert.maybe = createModifiedModifier(
  658.               assertModifier,
  659.               maybe,
  660.               "maybe "
  661.             )),
  662.             collections.forEach(function (key) {
  663.               predicates[key].of = createModifiedFunctions([
  664.                 ofModifier.bind(null, null),
  665.                 predicates[key],
  666.                 predicates,
  667.                 {},
  668.                 "",
  669.               ])
  670.             }),
  671.             createOfModifiers(assert, assertModifier),
  672.             createOfModifiers(not, notModifier),
  673.             collections.forEach(function (key) {
  674.               ;(maybe[key].of = createModifiedFunctions([
  675.                 ofModifier.bind(null, "maybe"),
  676.                 predicates[key],
  677.                 predicates,
  678.                 {},
  679.                 "",
  680.               ])),
  681.                 (assert.maybe[key].of = createModifiedModifier(
  682.                   assertModifier,
  683.                   maybe[key].of
  684.                 )),
  685.                 (assert.not[key].of = createModifiedModifier(
  686.                   assertModifier,
  687.                   not[key].of
  688.                 ))
  689.             }),
  690.             (function (functions) {
  691.               void 0 ===
  692.                 (__WEBPACK_AMD_DEFINE_RESULT__ = function () {
  693.                   return functions
  694.                 }.call(exports, __webpack_require__, exports, module)) ||
  695.                 (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)
  696.             })(mixin(functions, { assert, not, maybe }))
  697.         })()
  698.       },
  699.       228: module => {
  700.         "use strict"
  701.         const createAbortError = () => {
  702.             const error = new Error("Delay aborted")
  703.             return (error.name = "AbortError"), error
  704.           },
  705.           createDelay =
  706.             ({ clearTimeout: defaultClear, setTimeout: set, willResolve }) =>
  707.             (ms, { value, signal } = {}) => {
  708.               if (signal && signal.aborted)
  709.                 return Promise.reject(createAbortError())
  710.               let timeoutId, settle, rejectFn
  711.               const clear = defaultClear || clearTimeout,
  712.                 signalListener = () => {
  713.                   clear(timeoutId), rejectFn(createAbortError())
  714.                 },
  715.                 delayPromise = new Promise((resolve, reject) => {
  716.                   ;(settle = () => {
  717.                     signal &&
  718.                       signal.removeEventListener("abort", signalListener),
  719.                       willResolve ? resolve(value) : reject(value)
  720.                   }),
  721.                     (rejectFn = reject),
  722.                     (timeoutId = (set || setTimeout)(settle, ms))
  723.                 })
  724.               return (
  725.                 signal &&
  726.                   signal.addEventListener("abort", signalListener, {
  727.                     once: !0,
  728.                   }),
  729.                 (delayPromise.clear = () => {
  730.                   clear(timeoutId), (timeoutId = null), settle()
  731.                 }),
  732.                 delayPromise
  733.               )
  734.             },
  735.           delay = createDelay({ willResolve: !0 })
  736.         ;(delay.reject = createDelay({ willResolve: !1 })),
  737.           (delay.range = (minimum, maximum, options) =>
  738.             delay(
  739.               ((minimum, maximum) =>
  740.                 Math.floor(Math.random() * (maximum - minimum + 1) + minimum))(
  741.                 minimum,
  742.                 maximum
  743.               ),
  744.               options
  745.             )),
  746.           (delay.createWithTimers = ({ clearTimeout, setTimeout }) => {
  747.             const delay = createDelay({
  748.               clearTimeout,
  749.               setTimeout,
  750.               willResolve: !0,
  751.             })
  752.             return (
  753.               (delay.reject = createDelay({
  754.                 clearTimeout,
  755.                 setTimeout,
  756.                 willResolve: !1,
  757.               })),
  758.               delay
  759.             )
  760.           }),
  761.           (module.exports = delay),
  762.           (module.exports.default = delay)
  763.       },
  764.       633: () => {},
  765.     },
  766.     __webpack_module_cache__ = {}
  767.   function __webpack_require__(moduleId) {
  768.     var cachedModule = __webpack_module_cache__[moduleId]
  769.     if (void 0 !== cachedModule) return cachedModule.exports
  770.     var module = (__webpack_module_cache__[moduleId] = { exports: {} })
  771.     return (
  772.       __webpack_modules__[moduleId].call(
  773.         module.exports,
  774.         module,
  775.         module.exports,
  776.         __webpack_require__
  777.       ),
  778.       module.exports
  779.     )
  780.   }
  781.   ;(__webpack_require__.n = module => {
  782.     var getter =
  783.       module && module.__esModule ? () => module.default : () => module
  784.     return __webpack_require__.d(getter, { a: getter }), getter
  785.   }),
  786.     (__webpack_require__.d = (exports, definition) => {
  787.       for (var key in definition)
  788.         __webpack_require__.o(definition, key) &&
  789.           !__webpack_require__.o(exports, key) &&
  790.           Object.defineProperty(exports, key, {
  791.             enumerable: !0,
  792.             get: definition[key],
  793.           })
  794.     }),
  795.     (__webpack_require__.o = (obj, prop) =>
  796.       Object.prototype.hasOwnProperty.call(obj, prop)),
  797.     (() => {
  798.       "use strict"
  799.       const external_log_namespaceObject = log
  800.       const lib = __webpack_require__(494).assert,
  801.         tapNonNull = x => (lib(null != x), x)
  802.       function sleep(time) {
  803.         return (
  804.           time || (time = 0),
  805.           new Promise(function (res) {
  806.             return setTimeout(res, time)
  807.           })
  808.         )
  809.       }
  810.       function randomToken() {
  811.         return Math.random().toString(36).substring(2)
  812.       }
  813.       var lastMs = 0,
  814.         additional = 0
  815.       function microSeconds() {
  816.         var ms = new Date().getTime()
  817.         return ms === lastMs
  818.           ? 1e3 * ms + ++additional
  819.           : ((lastMs = ms), (additional = 0), 1e3 * ms)
  820.       }
  821.       var isNode =
  822.         "[object process]" ===
  823.         Object.prototype.toString.call(
  824.           "undefined" != typeof process ? process : 0
  825.         )
  826.       const methods_native = {
  827.         create: function (channelName) {
  828.           var state = {
  829.             messagesCallback: null,
  830.             bc: new BroadcastChannel(channelName),
  831.             subFns: [],
  832.           }
  833.           return (
  834.             (state.bc.onmessage = function (msg) {
  835.               state.messagesCallback && state.messagesCallback(msg.data)
  836.             }),
  837.             state
  838.           )
  839.         },
  840.         close: function (channelState) {
  841.           channelState.bc.close(), (channelState.subFns = [])
  842.         },
  843.         onMessage: function (channelState, fn) {
  844.           channelState.messagesCallback = fn
  845.         },
  846.         postMessage: function (channelState, messageJson) {
  847.           try {
  848.             return (
  849.               channelState.bc.postMessage(messageJson, !1), Promise.resolve()
  850.             )
  851.           } catch (err) {
  852.             return Promise.reject(err)
  853.           }
  854.         },
  855.         canBeUsed: function () {
  856.           if (isNode && "undefined" == typeof window) return !1
  857.           if ("function" == typeof BroadcastChannel) {
  858.             if (BroadcastChannel._pubkey)
  859.               throw new Error(
  860.                 "BroadcastChannel: Do not overwrite window.BroadcastChannel with this module, this is not a polyfill"
  861.               )
  862.             return !0
  863.           }
  864.           return !1
  865.         },
  866.         type: "native",
  867.         averageResponseTime: function () {
  868.           return 150
  869.         },
  870.         microSeconds,
  871.       }
  872.       var ObliviousSet = (function () {
  873.         function ObliviousSet(ttl) {
  874.           ;(this.ttl = ttl), (this.set = new Set()), (this.timeMap = new Map())
  875.         }
  876.         return (
  877.           (ObliviousSet.prototype.has = function (value) {
  878.             return this.set.has(value)
  879.           }),
  880.           (ObliviousSet.prototype.add = function (value) {
  881.             var _this = this
  882.             this.timeMap.set(value, now()),
  883.               this.set.add(value),
  884.               setTimeout(function () {
  885.                 !(function (obliviousSet) {
  886.                   var olderThen = now() - obliviousSet.ttl,
  887.                     iterator = obliviousSet.set[Symbol.iterator]()
  888.                   for (;;) {
  889.                     var value = iterator.next().value
  890.                     if (!value) return
  891.                     if (!(obliviousSet.timeMap.get(value) < olderThen)) return
  892.                     obliviousSet.timeMap.delete(value),
  893.                       obliviousSet.set.delete(value)
  894.                   }
  895.                 })(_this)
  896.               }, 0)
  897.           }),
  898.           (ObliviousSet.prototype.clear = function () {
  899.             this.set.clear(), this.timeMap.clear()
  900.           }),
  901.           ObliviousSet
  902.         )
  903.       })()
  904.       function now() {
  905.         return new Date().getTime()
  906.       }
  907.       function options_fillOptionsWithDefaults() {
  908.         var originalOptions =
  909.             arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {},
  910.           options = JSON.parse(JSON.stringify(originalOptions))
  911.         return (
  912.           void 0 === options.webWorkerSupport &&
  913.             (options.webWorkerSupport = !0),
  914.           options.idb || (options.idb = {}),
  915.           options.idb.ttl || (options.idb.ttl = 45e3),
  916.           options.idb.fallbackInterval || (options.idb.fallbackInterval = 150),
  917.           originalOptions.idb &&
  918.             "function" == typeof originalOptions.idb.onclose &&
  919.             (options.idb.onclose = originalOptions.idb.onclose),
  920.           options.localstorage || (options.localstorage = {}),
  921.           options.localstorage.removeTimeout ||
  922.             (options.localstorage.removeTimeout = 6e4),
  923.           originalOptions.methods &&
  924.             (options.methods = originalOptions.methods),
  925.           options.node || (options.node = {}),
  926.           options.node.ttl || (options.node.ttl = 12e4),
  927.           void 0 === options.node.useFastPath &&
  928.             (options.node.useFastPath = !0),
  929.           options
  930.         )
  931.       }
  932.       function getIdb() {
  933.         if ("undefined" != typeof indexedDB) return indexedDB
  934.         if ("undefined" != typeof window) {
  935.           if (void 0 !== window.mozIndexedDB) return window.mozIndexedDB
  936.           if (void 0 !== window.webkitIndexedDB) return window.webkitIndexedDB
  937.           if (void 0 !== window.msIndexedDB) return window.msIndexedDB
  938.         }
  939.         return !1
  940.       }
  941.       function getMessagesHigherThan(db, lastCursorId) {
  942.         var objectStore = db.transaction("messages").objectStore("messages"),
  943.           ret = []
  944.         return new Promise(function (res) {
  945.           ;(function () {
  946.             try {
  947.               var keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, 1 / 0)
  948.               return objectStore.openCursor(keyRangeValue)
  949.             } catch (e) {
  950.               return objectStore.openCursor()
  951.             }
  952.           })().onsuccess = function (ev) {
  953.             var cursor = ev.target.result
  954.             cursor
  955.               ? cursor.value.id < lastCursorId + 1
  956.                 ? cursor.continue(lastCursorId + 1)
  957.                 : (ret.push(cursor.value), cursor.continue())
  958.               : res(ret)
  959.           }
  960.         })
  961.       }
  962.       function cleanOldMessages(db, ttl) {
  963.         return (function (db, ttl) {
  964.           var olderThen = new Date().getTime() - ttl,
  965.             objectStore = db.transaction("messages").objectStore("messages"),
  966.             ret = []
  967.           return new Promise(function (res) {
  968.             objectStore.openCursor().onsuccess = function (ev) {
  969.               var cursor = ev.target.result
  970.               if (cursor) {
  971.                 var msgObk = cursor.value
  972.                 if (!(msgObk.time < olderThen)) return void res(ret)
  973.                 ret.push(msgObk), cursor.continue()
  974.               } else res(ret)
  975.             }
  976.           })
  977.         })(db, ttl).then(function (tooOld) {
  978.           return Promise.all(
  979.             tooOld.map(function (msgObj) {
  980.               return (function (db, id) {
  981.                 var request = db
  982.                   .transaction(["messages"], "readwrite")
  983.                   .objectStore("messages")
  984.                   .delete(id)
  985.                 return new Promise(function (res) {
  986.                   request.onsuccess = function () {
  987.                     return res()
  988.                   }
  989.                 })
  990.               })(db, msgObj.id)
  991.             })
  992.           )
  993.         })
  994.       }
  995.       function _readLoop(state) {
  996.         state.closed ||
  997.           readNewMessages(state)
  998.             .then(function () {
  999.               return sleep(state.options.idb.fallbackInterval)
  1000.             })
  1001.             .then(function () {
  1002.               return _readLoop(state)
  1003.             })
  1004.       }
  1005.       function readNewMessages(state) {
  1006.         return state.closed
  1007.           ? Promise.resolve()
  1008.           : state.messagesCallback
  1009.           ? getMessagesHigherThan(state.db, state.lastCursorId).then(function (
  1010.               newerMessages
  1011.             ) {
  1012.               return (
  1013.                 newerMessages
  1014.                   .filter(function (msgObj) {
  1015.                     return !!msgObj
  1016.                   })
  1017.                   .map(function (msgObj) {
  1018.                     return (
  1019.                       msgObj.id > state.lastCursorId &&
  1020.                         (state.lastCursorId = msgObj.id),
  1021.                       msgObj
  1022.                     )
  1023.                   })
  1024.                   .filter(function (msgObj) {
  1025.                     return (function (msgObj, state) {
  1026.                       return !(
  1027.                         msgObj.uuid === state.uuid ||
  1028.                         state.eMIs.has(msgObj.id) ||
  1029.                         msgObj.data.time < state.messagesCallbackTime
  1030.                       )
  1031.                     })(msgObj, state)
  1032.                   })
  1033.                   .sort(function (msgObjA, msgObjB) {
  1034.                     return msgObjA.time - msgObjB.time
  1035.                   })
  1036.                   .forEach(function (msgObj) {
  1037.                     state.messagesCallback &&
  1038.                       (state.eMIs.add(msgObj.id),
  1039.                       state.messagesCallback(msgObj.data))
  1040.                   }),
  1041.                 Promise.resolve()
  1042.               )
  1043.             })
  1044.           : Promise.resolve()
  1045.       }
  1046.       const indexed_db = {
  1047.         create: function (channelName, options) {
  1048.           return (
  1049.             (options = options_fillOptionsWithDefaults(options)),
  1050.             (function (channelName) {
  1051.               var dbName = "pubkey.broadcast-channel-0-" + channelName,
  1052.                 openRequest = getIdb().open(dbName, 1)
  1053.               return (
  1054.                 (openRequest.onupgradeneeded = function (ev) {
  1055.                   ev.target.result.createObjectStore("messages", {
  1056.                     keyPath: "id",
  1057.                     autoIncrement: !0,
  1058.                   })
  1059.                 }),
  1060.                 new Promise(function (res, rej) {
  1061.                   ;(openRequest.onerror = function (ev) {
  1062.                     return rej(ev)
  1063.                   }),
  1064.                     (openRequest.onsuccess = function () {
  1065.                       res(openRequest.result)
  1066.                     })
  1067.                 })
  1068.               )
  1069.             })(channelName).then(function (db) {
  1070.               var state = {
  1071.                 closed: !1,
  1072.                 lastCursorId: 0,
  1073.                 channelName,
  1074.                 options,
  1075.                 uuid: randomToken(),
  1076.                 eMIs: new ObliviousSet(2 * options.idb.ttl),
  1077.                 writeBlockPromise: Promise.resolve(),
  1078.                 messagesCallback: null,
  1079.                 readQueuePromises: [],
  1080.                 db,
  1081.               }
  1082.               return (
  1083.                 (db.onclose = function () {
  1084.                   ;(state.closed = !0),
  1085.                     options.idb.onclose && options.idb.onclose()
  1086.                 }),
  1087.                 _readLoop(state),
  1088.                 state
  1089.               )
  1090.             })
  1091.           )
  1092.         },
  1093.         close: function (channelState) {
  1094.           ;(channelState.closed = !0), channelState.db.close()
  1095.         },
  1096.         onMessage: function (channelState, fn, time) {
  1097.           ;(channelState.messagesCallbackTime = time),
  1098.             (channelState.messagesCallback = fn),
  1099.             readNewMessages(channelState)
  1100.         },
  1101.         postMessage: function (channelState, messageJson) {
  1102.           return (
  1103.             (channelState.writeBlockPromise = channelState.writeBlockPromise
  1104.               .then(function () {
  1105.                 return (function (db, readerUuid, messageJson) {
  1106.                   var writeObject = {
  1107.                       uuid: readerUuid,
  1108.                       time: new Date().getTime(),
  1109.                       data: messageJson,
  1110.                     },
  1111.                     transaction = db.transaction(["messages"], "readwrite")
  1112.                   return new Promise(function (res, rej) {
  1113.                     ;(transaction.oncomplete = function () {
  1114.                       return res()
  1115.                     }),
  1116.                       (transaction.onerror = function (ev) {
  1117.                         return rej(ev)
  1118.                       }),
  1119.                       transaction.objectStore("messages").add(writeObject)
  1120.                   })
  1121.                 })(channelState.db, channelState.uuid, messageJson)
  1122.               })
  1123.               .then(function () {
  1124.                 0 ===
  1125.                   (function (min, max) {
  1126.                     return Math.floor(Math.random() * (max - min + 1) + min)
  1127.                   })(0, 10) &&
  1128.                   cleanOldMessages(
  1129.                     channelState.db,
  1130.                     channelState.options.idb.ttl
  1131.                   )
  1132.               })),
  1133.             channelState.writeBlockPromise
  1134.           )
  1135.         },
  1136.         canBeUsed: function () {
  1137.           return !isNode && !!getIdb()
  1138.         },
  1139.         type: "idb",
  1140.         averageResponseTime: function (options) {
  1141.           return 2 * options.idb.fallbackInterval
  1142.         },
  1143.         microSeconds,
  1144.       }
  1145.       function getLocalStorage() {
  1146.         var localStorage
  1147.         if ("undefined" == typeof window) return null
  1148.         try {
  1149.           ;(localStorage = window.localStorage),
  1150.             (localStorage =
  1151.               window["ie8-eventlistener/storage"] || window.localStorage)
  1152.         } catch (e) {}
  1153.         return localStorage
  1154.       }
  1155.       function storageKey(channelName) {
  1156.         return "pubkey.broadcastChannel-" + channelName
  1157.       }
  1158.       function localstorage_canBeUsed() {
  1159.         if (isNode) return !1
  1160.         var ls = getLocalStorage()
  1161.         if (!ls) return !1
  1162.         try {
  1163.           var key = "__broadcastchannel_check"
  1164.           ls.setItem(key, "works"), ls.removeItem(key)
  1165.         } catch (e) {
  1166.           return !1
  1167.         }
  1168.         return !0
  1169.       }
  1170.       const localstorage = {
  1171.         create: function (channelName, options) {
  1172.           if (
  1173.             ((options = options_fillOptionsWithDefaults(options)),
  1174.             !localstorage_canBeUsed())
  1175.           )
  1176.             throw new Error("BroadcastChannel: localstorage cannot be used")
  1177.           var uuid = randomToken(),
  1178.             eMIs = new ObliviousSet(options.localstorage.removeTimeout),
  1179.             state = { channelName, uuid, eMIs }
  1180.           return (
  1181.             (state.listener = (function (channelName, fn) {
  1182.               var key = storageKey(channelName),
  1183.                 listener = function (ev) {
  1184.                   ev.key === key && fn(JSON.parse(ev.newValue))
  1185.                 }
  1186.               return window.addEventListener("storage", listener), listener
  1187.             })(channelName, function (msgObj) {
  1188.               state.messagesCallback &&
  1189.                 msgObj.uuid !== uuid &&
  1190.                 msgObj.token &&
  1191.                 !eMIs.has(msgObj.token) &&
  1192.                 ((msgObj.data.time &&
  1193.                   msgObj.data.time < state.messagesCallbackTime) ||
  1194.                   (eMIs.add(msgObj.token), state.messagesCallback(msgObj.data)))
  1195.             })),
  1196.             state
  1197.           )
  1198.         },
  1199.         close: function (channelState) {
  1200.           var listener
  1201.           ;(listener = channelState.listener),
  1202.             window.removeEventListener("storage", listener)
  1203.         },
  1204.         onMessage: function (channelState, fn, time) {
  1205.           ;(channelState.messagesCallbackTime = time),
  1206.             (channelState.messagesCallback = fn)
  1207.         },
  1208.         postMessage: function (channelState, messageJson) {
  1209.           return new Promise(function (res) {
  1210.             sleep().then(function () {
  1211.               var key = storageKey(channelState.channelName),
  1212.                 writeObj = {
  1213.                   token: randomToken(),
  1214.                   time: new Date().getTime(),
  1215.                   data: messageJson,
  1216.                   uuid: channelState.uuid,
  1217.                 },
  1218.                 value = JSON.stringify(writeObj)
  1219.               getLocalStorage().setItem(key, value)
  1220.               var ev = document.createEvent("Event")
  1221.               ev.initEvent("storage", !0, !0),
  1222.                 (ev.key = key),
  1223.                 (ev.newValue = value),
  1224.                 window.dispatchEvent(ev),
  1225.                 res()
  1226.             })
  1227.           })
  1228.         },
  1229.         canBeUsed: localstorage_canBeUsed,
  1230.         type: "localstorage",
  1231.         averageResponseTime: function () {
  1232.           var userAgent = navigator.userAgent.toLowerCase()
  1233.           return userAgent.includes("safari") && !userAgent.includes("chrome")
  1234.             ? 240
  1235.             : 120
  1236.         },
  1237.         microSeconds,
  1238.       }
  1239.       var simulate_microSeconds = microSeconds,
  1240.         SIMULATE_CHANNELS = new Set()
  1241.       const simulate = {
  1242.         create: function (channelName) {
  1243.           var state = { name: channelName, messagesCallback: null }
  1244.           return SIMULATE_CHANNELS.add(state), state
  1245.         },
  1246.         close: function (channelState) {
  1247.           SIMULATE_CHANNELS.delete(channelState)
  1248.         },
  1249.         onMessage: function (channelState, fn) {
  1250.           channelState.messagesCallback = fn
  1251.         },
  1252.         postMessage: function (channelState, messageJson) {
  1253.           return new Promise(function (res) {
  1254.             return setTimeout(function () {
  1255.               Array.from(SIMULATE_CHANNELS)
  1256.                 .filter(function (channel) {
  1257.                   return channel.name === channelState.name
  1258.                 })
  1259.                 .filter(function (channel) {
  1260.                   return channel !== channelState
  1261.                 })
  1262.                 .filter(function (channel) {
  1263.                   return !!channel.messagesCallback
  1264.                 })
  1265.                 .forEach(function (channel) {
  1266.                   return channel.messagesCallback(messageJson)
  1267.                 }),
  1268.                 res()
  1269.             }, 5)
  1270.           })
  1271.         },
  1272.         canBeUsed: function () {
  1273.           return !0
  1274.         },
  1275.         type: "simulate",
  1276.         averageResponseTime: function () {
  1277.           return 5
  1278.         },
  1279.         microSeconds: simulate_microSeconds,
  1280.       }
  1281.       var METHODS = [methods_native, indexed_db, localstorage]
  1282.       if (isNode) {
  1283.         var NodeMethod = __webpack_require__(633)
  1284.         "function" == typeof NodeMethod.canBeUsed && METHODS.push(NodeMethod)
  1285.       }
  1286.       var ENFORCED_OPTIONS,
  1287.         broadcast_channel_BroadcastChannel = function (name, options) {
  1288.           var channel, maybePromise, obj
  1289.           ;(this.name = name),
  1290.             ENFORCED_OPTIONS && (options = ENFORCED_OPTIONS),
  1291.             (this.options = options_fillOptionsWithDefaults(options)),
  1292.             (this.method = (function (options) {
  1293.               var chooseMethods = []
  1294.                 .concat(options.methods, METHODS)
  1295.                 .filter(Boolean)
  1296.               if (options.type) {
  1297.                 if ("simulate" === options.type) return simulate
  1298.                 var ret = chooseMethods.find(function (m) {
  1299.                   return m.type === options.type
  1300.                 })
  1301.                 if (ret) return ret
  1302.                 throw new Error("method-type " + options.type + " not found")
  1303.               }
  1304.               options.webWorkerSupport ||
  1305.                 isNode ||
  1306.                 (chooseMethods = chooseMethods.filter(function (m) {
  1307.                   return "idb" !== m.type
  1308.                 }))
  1309.               var useMethod = chooseMethods.find(function (method) {
  1310.                 return method.canBeUsed()
  1311.               })
  1312.               if (useMethod) return useMethod
  1313.               throw new Error(
  1314.                 "No useable methode found:" +
  1315.                   JSON.stringify(
  1316.                     METHODS.map(function (m) {
  1317.                       return m.type
  1318.                     })
  1319.                   )
  1320.               )
  1321.             })(this.options)),
  1322.             (this._iL = !1),
  1323.             (this._onML = null),
  1324.             (this._addEL = { message: [], internal: [] }),
  1325.             (this._uMP = new Set()),
  1326.             (this._befC = []),
  1327.             (this._prepP = null),
  1328.             (maybePromise = (channel = this).method.create(
  1329.               channel.name,
  1330.               channel.options
  1331.             )),
  1332.             (obj = maybePromise) && "function" == typeof obj.then
  1333.               ? ((channel._prepP = maybePromise),
  1334.                 maybePromise.then(function (s) {
  1335.                   channel._state = s
  1336.                 }))
  1337.               : (channel._state = maybePromise)
  1338.         }
  1339.       function _post(broadcastChannel, type, msg) {
  1340.         var msgObj = {
  1341.           time: broadcastChannel.method.microSeconds(),
  1342.           type,
  1343.           data: msg,
  1344.         }
  1345.         return (
  1346.           broadcastChannel._prepP ? broadcastChannel._prepP : Promise.resolve()
  1347.         ).then(function () {
  1348.           var sendPromise = broadcastChannel.method.postMessage(
  1349.             broadcastChannel._state,
  1350.             msgObj
  1351.           )
  1352.           return (
  1353.             broadcastChannel._uMP.add(sendPromise),
  1354.             sendPromise.catch().then(function () {
  1355.               return broadcastChannel._uMP.delete(sendPromise)
  1356.             }),
  1357.             sendPromise
  1358.           )
  1359.         })
  1360.       }
  1361.       function _hasMessageListeners(channel) {
  1362.         return (
  1363.           channel._addEL.message.length > 0 ||
  1364.           channel._addEL.internal.length > 0
  1365.         )
  1366.       }
  1367.       function _addListenerObject(channel, type, obj) {
  1368.         channel._addEL[type].push(obj),
  1369.           (function (channel) {
  1370.             if (!channel._iL && _hasMessageListeners(channel)) {
  1371.               var listenerFn = function (msgObj) {
  1372.                   channel._addEL[msgObj.type].forEach(function (obj) {
  1373.                     msgObj.time >= obj.time && obj.fn(msgObj.data)
  1374.                   })
  1375.                 },
  1376.                 time = channel.method.microSeconds()
  1377.               channel._prepP
  1378.                 ? channel._prepP.then(function () {
  1379.                     ;(channel._iL = !0),
  1380.                       channel.method.onMessage(channel._state, listenerFn, time)
  1381.                   })
  1382.                 : ((channel._iL = !0),
  1383.                   channel.method.onMessage(channel._state, listenerFn, time))
  1384.             }
  1385.           })(channel)
  1386.       }
  1387.       function _removeListenerObject(channel, type, obj) {
  1388.         ;(channel._addEL[type] = channel._addEL[type].filter(function (o) {
  1389.           return o !== obj
  1390.         })),
  1391.           (function (channel) {
  1392.             if (channel._iL && !_hasMessageListeners(channel)) {
  1393.               channel._iL = !1
  1394.               var time = channel.method.microSeconds()
  1395.               channel.method.onMessage(channel._state, null, time)
  1396.             }
  1397.           })(channel)
  1398.       }
  1399.       ;(broadcast_channel_BroadcastChannel._pubkey = !0),
  1400.         (broadcast_channel_BroadcastChannel.prototype = {
  1401.           postMessage: function (msg) {
  1402.             if (this.closed)
  1403.               throw new Error(
  1404.                 "BroadcastChannel.postMessage(): Cannot post message after channel has closed"
  1405.               )
  1406.             return _post(this, "message", msg)
  1407.           },
  1408.           postInternal: function (msg) {
  1409.             return _post(this, "internal", msg)
  1410.           },
  1411.           set onmessage(fn) {
  1412.             var listenObj = { time: this.method.microSeconds(), fn }
  1413.             _removeListenerObject(this, "message", this._onML),
  1414.               fn && "function" == typeof fn
  1415.                 ? ((this._onML = listenObj),
  1416.                   _addListenerObject(this, "message", listenObj))
  1417.                 : (this._onML = null)
  1418.           },
  1419.           addEventListener: function (type, fn) {
  1420.             _addListenerObject(this, type, {
  1421.               time: this.method.microSeconds(),
  1422.               fn,
  1423.             })
  1424.           },
  1425.           removeEventListener: function (type, fn) {
  1426.             _removeListenerObject(
  1427.               this,
  1428.               type,
  1429.               this._addEL[type].find(function (obj) {
  1430.                 return obj.fn === fn
  1431.               })
  1432.             )
  1433.           },
  1434.           close: function () {
  1435.             var _this = this
  1436.             if (!this.closed) {
  1437.               this.closed = !0
  1438.               var awaitPrepare = this._prepP ? this._prepP : Promise.resolve()
  1439.               return (
  1440.                 (this._onML = null),
  1441.                 (this._addEL.message = []),
  1442.                 awaitPrepare
  1443.                   .then(function () {
  1444.                     return Promise.all(Array.from(_this._uMP))
  1445.                   })
  1446.                   .then(function () {
  1447.                     return Promise.all(
  1448.                       _this._befC.map(function (fn) {
  1449.                         return fn()
  1450.                       })
  1451.                     )
  1452.                   })
  1453.                   .then(function () {
  1454.                     return _this.method.close(_this._state)
  1455.                   })
  1456.               )
  1457.             }
  1458.           },
  1459.           get type() {
  1460.             return this.method.type
  1461.           },
  1462.           get isClosed() {
  1463.             return this.closed
  1464.           },
  1465.         })
  1466.       var delay = __webpack_require__(228),
  1467.         delay_default = __webpack_require__.n(delay)
  1468.       function function_identity(a) {
  1469.         return a
  1470.       }
  1471.       function constant(a) {
  1472.         return function () {
  1473.           return a
  1474.         }
  1475.       }
  1476.       function function_pipe(
  1477.         a,
  1478.         ab,
  1479.         bc,
  1480.         cd,
  1481.         de,
  1482.         ef,
  1483.         fg,
  1484.         gh,
  1485.         hi,
  1486.         ij,
  1487.         jk,
  1488.         kl,
  1489.         lm,
  1490.         mn,
  1491.         no,
  1492.         op,
  1493.         pq,
  1494.         qr,
  1495.         rs,
  1496.         st
  1497.       ) {
  1498.         switch (arguments.length) {
  1499.           case 1:
  1500.             return a
  1501.           case 2:
  1502.             return ab(a)
  1503.           case 3:
  1504.             return bc(ab(a))
  1505.           case 4:
  1506.             return cd(bc(ab(a)))
  1507.           case 5:
  1508.             return de(cd(bc(ab(a))))
  1509.           case 6:
  1510.             return ef(de(cd(bc(ab(a)))))
  1511.           case 7:
  1512.             return fg(ef(de(cd(bc(ab(a))))))
  1513.           case 8:
  1514.             return gh(fg(ef(de(cd(bc(ab(a)))))))
  1515.           case 9:
  1516.             return hi(gh(fg(ef(de(cd(bc(ab(a))))))))
  1517.           case 10:
  1518.             return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))
  1519.           case 11:
  1520.             return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))
  1521.           case 12:
  1522.             return kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))
  1523.           case 13:
  1524.             return lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))
  1525.           case 14:
  1526.             return mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))
  1527.           case 15:
  1528.             return no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))
  1529.           case 16:
  1530.             return op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))
  1531.           case 17:
  1532.             return pq(
  1533.               op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))
  1534.             )
  1535.           case 18:
  1536.             return qr(
  1537.               pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))))
  1538.             )
  1539.           case 19:
  1540.             return rs(
  1541.               qr(
  1542.                 pq(
  1543.                   op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))
  1544.                 )
  1545.               )
  1546.             )
  1547.           case 20:
  1548.             return st(
  1549.               rs(
  1550.                 qr(
  1551.                   pq(
  1552.                     op(
  1553.                       no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))
  1554.                     )
  1555.                   )
  1556.                 )
  1557.               )
  1558.             )
  1559.         }
  1560.       }
  1561.       const getTeaserContainers = node =>
  1562.           Array.from(
  1563.             node.querySelectorAll(
  1564.               ".views-responsive-grid, .node-playlist .field-name-field-videos"
  1565.             )
  1566.           ).filter(grid =>
  1567.             grid.querySelector(
  1568.               ".node-teaser, .node-sidebar_teaser, .node-wide_teaser"
  1569.             )
  1570.           ),
  1571.         scriptIdentifier = "iwara-custom-sort-1340362664231628",
  1572.         partial_lib =
  1573.           (f, ...headArgs) =>
  1574.           (...restArgs) =>
  1575.             f(...headArgs, ...restArgs),
  1576.         tapIs = (constructor, x) => (lib(x instanceof constructor), x)
  1577.       function flap(F) {
  1578.         return function (a) {
  1579.           return function (fab) {
  1580.             return F.map(fab, function (f) {
  1581.               return f(a)
  1582.             })
  1583.           }
  1584.         }
  1585.       }
  1586.       var isSome = function (fa) {
  1587.           return "Some" === fa._tag
  1588.         },
  1589.         none = { _tag: "None" },
  1590.         some = function (a) {
  1591.           return { _tag: "Some", value: a }
  1592.         },
  1593.         emptyReadonlyArray = []
  1594.       Object.prototype.hasOwnProperty, constant(0)
  1595.       var a
  1596.       a = void 0
  1597.       var ReadonlyNonEmptyArray_spreadArray = function (to, from) {
  1598.           for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
  1599.             to[j] = from[i]
  1600.           return to
  1601.         },
  1602.         ReadonlyNonEmptyArray_empty = emptyReadonlyArray,
  1603.         appendW = function (end) {
  1604.           return function (init) {
  1605.             return ReadonlyNonEmptyArray_spreadArray(
  1606.               ReadonlyNonEmptyArray_spreadArray([], init),
  1607.               [end]
  1608.             )
  1609.           }
  1610.         },
  1611.         append = appendW
  1612.       var _map = function (fa, f) {
  1613.           return function_pipe(fa, ReadonlyNonEmptyArray_map(f))
  1614.         },
  1615.         ReadonlyNonEmptyArray_map = function (f) {
  1616.           return mapWithIndex(function (_, a) {
  1617.             return f(a)
  1618.           })
  1619.         },
  1620.         mapWithIndex = function (f) {
  1621.           return function (as) {
  1622.             for (
  1623.               var out = [f(0, ReadonlyNonEmptyArray_head(as))], i = 1;
  1624.               i < as.length;
  1625.               i++
  1626.             )
  1627.               out.push(f(i, as[i]))
  1628.             return out
  1629.           }
  1630.         },
  1631.         extract = function (as) {
  1632.           return as[0]
  1633.         },
  1634.         Functor = { URI: "ReadonlyNonEmptyArray", map: _map },
  1635.         ReadonlyNonEmptyArray_head = (flap(Functor), extract)
  1636.       var NonEmptyArray_spreadArray = function (to, from) {
  1637.           for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
  1638.             to[j] = from[i]
  1639.           return to
  1640.         },
  1641.         NonEmptyArray_appendW = function (end) {
  1642.           return function (init) {
  1643.             return NonEmptyArray_spreadArray(
  1644.               NonEmptyArray_spreadArray([], init),
  1645.               [end]
  1646.             )
  1647.           }
  1648.         },
  1649.         NonEmptyArray_append = NonEmptyArray_appendW
  1650.       var NonEmptyArray_map = function (fa, f) {
  1651.           return function_pipe(fa, es6_NonEmptyArray_map(f))
  1652.         },
  1653.         es6_NonEmptyArray_map = function (f) {
  1654.           return es6_NonEmptyArray_mapWithIndex(function (_, a) {
  1655.             return f(a)
  1656.           })
  1657.         },
  1658.         es6_NonEmptyArray_mapWithIndex = function (f) {
  1659.           return function (as) {
  1660.             for (
  1661.               var out = [f(0, NonEmptyArray_head(as))], i = 1;
  1662.               i < as.length;
  1663.               i++
  1664.             )
  1665.               out.push(f(i, as[i]))
  1666.             return out
  1667.           }
  1668.         },
  1669.         NonEmptyArray_Functor = {
  1670.           URI: "NonEmptyArray",
  1671.           map: NonEmptyArray_map,
  1672.         },
  1673.         NonEmptyArray_head =
  1674.           (flap(NonEmptyArray_Functor), ReadonlyNonEmptyArray_head)
  1675.       var separated = function (left, right) {
  1676.           return { left, right }
  1677.         },
  1678.         es6_Separated_map = function (f) {
  1679.           return function (fa) {
  1680.             return separated(Separated_left(fa), f(Separated_right(fa)))
  1681.           }
  1682.         },
  1683.         Separated_left =
  1684.           (flap({
  1685.             URI: "Separated",
  1686.             map: function (fa, f) {
  1687.               return function_pipe(fa, es6_Separated_map(f))
  1688.             },
  1689.           }),
  1690.           function (s) {
  1691.             return s.left
  1692.           }),
  1693.         Separated_right = function (s) {
  1694.           return s.right
  1695.         }
  1696.       function wiltDefault(T, C) {
  1697.         return function (F) {
  1698.           var traverseF = T.traverse(F)
  1699.           return function (wa, f) {
  1700.             return F.map(traverseF(wa, f), C.separate)
  1701.           }
  1702.         }
  1703.       }
  1704.       function witherDefault(T, C) {
  1705.         return function (F) {
  1706.           var traverseF = T.traverse(F)
  1707.           return function (wa, f) {
  1708.             return F.map(traverseF(wa, f), C.compact)
  1709.           }
  1710.         }
  1711.       }
  1712.       var ReadonlyArray_append = append
  1713.       var ReadonlyArray_map = function (fa, f) {
  1714.           return function_pipe(fa, es6_ReadonlyArray_map(f))
  1715.         },
  1716.         ReadonlyArray_reduce = function (fa, b, f) {
  1717.           return function_pipe(fa, es6_ReadonlyArray_reduce(b, f))
  1718.         },
  1719.         ReadonlyArray_foldMap = function (M) {
  1720.           var foldMapM = es6_ReadonlyArray_foldMap(M)
  1721.           return function (fa, f) {
  1722.             return function_pipe(fa, foldMapM(f))
  1723.           }
  1724.         },
  1725.         ReadonlyArray_reduceRight = function (fa, b, f) {
  1726.           return function_pipe(fa, es6_ReadonlyArray_reduceRight(b, f))
  1727.         },
  1728.         ReadonlyArray_traverse = function (F) {
  1729.           var traverseF = es6_ReadonlyArray_traverse(F)
  1730.           return function (ta, f) {
  1731.             return function_pipe(ta, traverseF(f))
  1732.           }
  1733.         },
  1734.         zero = function () {
  1735.           return ReadonlyArray_empty
  1736.         },
  1737.         es6_ReadonlyArray_map = function (f) {
  1738.           return function (fa) {
  1739.             return fa.map(function (a) {
  1740.               return f(a)
  1741.             })
  1742.           }
  1743.         },
  1744.         separate = function (fa) {
  1745.           for (
  1746.             var left = [], right = [], _i = 0, fa_1 = fa;
  1747.             _i < fa_1.length;
  1748.             _i++
  1749.           ) {
  1750.             var e = fa_1[_i]
  1751.             "Left" === e._tag ? left.push(e.left) : right.push(e.right)
  1752.           }
  1753.           return separated(left, right)
  1754.         },
  1755.         filterMapWithIndex = function (f) {
  1756.           return function (fa) {
  1757.             for (var out = [], i = 0; i < fa.length; i++) {
  1758.               var optionB = f(i, fa[i])
  1759.               isSome(optionB) && out.push(optionB.value)
  1760.             }
  1761.             return out
  1762.           }
  1763.         },
  1764.         filterMap = function (f) {
  1765.           return filterMapWithIndex(function (_, a) {
  1766.             return f(a)
  1767.           })
  1768.         },
  1769.         compact = filterMap(function_identity),
  1770.         es6_ReadonlyArray_foldMapWithIndex = function (M) {
  1771.           return function (f) {
  1772.             return function (fa) {
  1773.               return fa.reduce(function (b, a, i) {
  1774.                 return M.concat(b, f(i, a))
  1775.               }, M.empty)
  1776.             }
  1777.           }
  1778.         },
  1779.         es6_ReadonlyArray_reduce = function (b, f) {
  1780.           return es6_ReadonlyArray_reduceWithIndex(b, function (_, b, a) {
  1781.             return f(b, a)
  1782.           })
  1783.         },
  1784.         es6_ReadonlyArray_foldMap = function (M) {
  1785.           var foldMapWithIndexM = es6_ReadonlyArray_foldMapWithIndex(M)
  1786.           return function (f) {
  1787.             return foldMapWithIndexM(function (_, a) {
  1788.               return f(a)
  1789.             })
  1790.           }
  1791.         },
  1792.         es6_ReadonlyArray_reduceWithIndex = function (b, f) {
  1793.           return function (fa) {
  1794.             for (var len = fa.length, out = b, i = 0; i < len; i++)
  1795.               out = f(i, out, fa[i])
  1796.             return out
  1797.           }
  1798.         },
  1799.         es6_ReadonlyArray_reduceRight = function (b, f) {
  1800.           return es6_ReadonlyArray_reduceRightWithIndex(b, function (_, a, b) {
  1801.             return f(a, b)
  1802.           })
  1803.         },
  1804.         es6_ReadonlyArray_reduceRightWithIndex = function (b, f) {
  1805.           return function (fa) {
  1806.             return fa.reduceRight(function (b, a, i) {
  1807.               return f(i, a, b)
  1808.             }, b)
  1809.           }
  1810.         },
  1811.         es6_ReadonlyArray_traverse = function (F) {
  1812.           var traverseWithIndexF = es6_ReadonlyArray_traverseWithIndex(F)
  1813.           return function (f) {
  1814.             return traverseWithIndexF(function (_, a) {
  1815.               return f(a)
  1816.             })
  1817.           }
  1818.         },
  1819.         ReadonlyArray_sequence = function (F) {
  1820.           return function (ta) {
  1821.             return ReadonlyArray_reduce(ta, F.of(zero()), function (fas, fa) {
  1822.               return F.ap(
  1823.                 F.map(fas, function (as) {
  1824.                   return function (a) {
  1825.                     return function_pipe(as, ReadonlyArray_append(a))
  1826.                   }
  1827.                 }),
  1828.                 fa
  1829.               )
  1830.             })
  1831.           }
  1832.         },
  1833.         es6_ReadonlyArray_traverseWithIndex = function (F) {
  1834.           return function (f) {
  1835.             return es6_ReadonlyArray_reduceWithIndex(
  1836.               F.of(zero()),
  1837.               function (i, fbs, a) {
  1838.                 return F.ap(
  1839.                   F.map(fbs, function (bs) {
  1840.                     return function (b) {
  1841.                       return function_pipe(bs, ReadonlyArray_append(b))
  1842.                     }
  1843.                   }),
  1844.                   f(i, a)
  1845.                 )
  1846.               }
  1847.             )
  1848.           }
  1849.         },
  1850.         ReadonlyArray_Functor = {
  1851.           URI: "ReadonlyArray",
  1852.           map: ReadonlyArray_map,
  1853.         },
  1854.         Compactable =
  1855.           (flap(ReadonlyArray_Functor),
  1856.           { URI: "ReadonlyArray", compact, separate }),
  1857.         ReadonlyArray_Traversable = {
  1858.           URI: "ReadonlyArray",
  1859.           map: ReadonlyArray_map,
  1860.           reduce: ReadonlyArray_reduce,
  1861.           foldMap: ReadonlyArray_foldMap,
  1862.           reduceRight: ReadonlyArray_reduceRight,
  1863.           traverse: ReadonlyArray_traverse,
  1864.           sequence: ReadonlyArray_sequence,
  1865.         },
  1866.         ReadonlyArray_empty =
  1867.           (witherDefault(ReadonlyArray_Traversable, Compactable),
  1868.           wiltDefault(ReadonlyArray_Traversable, Compactable),
  1869.           ReadonlyNonEmptyArray_empty),
  1870.         Array_append = NonEmptyArray_append
  1871.       var Array_map = function (fa, f) {
  1872.           return function_pipe(fa, es6_Array_map(f))
  1873.         },
  1874.         Array_reduce = function (fa, b, f) {
  1875.           return function_pipe(fa, es6_Array_reduce(b, f))
  1876.         },
  1877.         Array_foldMap = function (M) {
  1878.           var foldMapM = es6_Array_foldMap(M)
  1879.           return function (fa, f) {
  1880.             return function_pipe(fa, foldMapM(f))
  1881.           }
  1882.         },
  1883.         Array_reduceRight = function (fa, b, f) {
  1884.           return function_pipe(fa, es6_Array_reduceRight(b, f))
  1885.         },
  1886.         Array_traverse = function (F) {
  1887.           var traverseF = es6_Array_traverse(F)
  1888.           return function (ta, f) {
  1889.             return function_pipe(ta, traverseF(f))
  1890.           }
  1891.         },
  1892.         es6_Array_map = function (f) {
  1893.           return function (fa) {
  1894.             return fa.map(function (a) {
  1895.               return f(a)
  1896.             })
  1897.           }
  1898.         },
  1899.         es6_Array_filterMapWithIndex = function (f) {
  1900.           return function (fa) {
  1901.             for (var out = [], i = 0; i < fa.length; i++) {
  1902.               var optionB = f(i, fa[i])
  1903.               isSome(optionB) && out.push(optionB.value)
  1904.             }
  1905.             return out
  1906.           }
  1907.         },
  1908.         es6_Array_filterMap = function (f) {
  1909.           return es6_Array_filterMapWithIndex(function (_, a) {
  1910.             return f(a)
  1911.           })
  1912.         },
  1913.         Array_compact = es6_Array_filterMap(function_identity),
  1914.         Array_separate = function (fa) {
  1915.           for (
  1916.             var left = [], right = [], _i = 0, fa_1 = fa;
  1917.             _i < fa_1.length;
  1918.             _i++
  1919.           ) {
  1920.             var e = fa_1[_i]
  1921.             "Left" === e._tag ? left.push(e.left) : right.push(e.right)
  1922.           }
  1923.           return separated(left, right)
  1924.         },
  1925.         es6_Array_filter = function (predicate) {
  1926.           return function (as) {
  1927.             return as.filter(predicate)
  1928.           }
  1929.         },
  1930.         es6_Array_foldMap = es6_ReadonlyArray_foldMap,
  1931.         es6_Array_reduce = es6_ReadonlyArray_reduce,
  1932.         es6_Array_reduceWithIndex = es6_ReadonlyArray_reduceWithIndex,
  1933.         es6_Array_reduceRight = es6_ReadonlyArray_reduceRight,
  1934.         es6_Array_traverse = function (F) {
  1935.           var traverseWithIndexF = es6_Array_traverseWithIndex(F)
  1936.           return function (f) {
  1937.             return traverseWithIndexF(function (_, a) {
  1938.               return f(a)
  1939.             })
  1940.           }
  1941.         },
  1942.         Array_sequence = function (F) {
  1943.           return function (ta) {
  1944.             return Array_reduce(ta, F.of([]), function (fas, fa) {
  1945.               return F.ap(
  1946.                 F.map(fas, function (as) {
  1947.                   return function (a) {
  1948.                     return function_pipe(as, Array_append(a))
  1949.                   }
  1950.                 }),
  1951.                 fa
  1952.               )
  1953.             })
  1954.           }
  1955.         },
  1956.         es6_Array_traverseWithIndex = function (F) {
  1957.           return function (f) {
  1958.             return es6_Array_reduceWithIndex(F.of([]), function (i, fbs, a) {
  1959.               return F.ap(
  1960.                 F.map(fbs, function (bs) {
  1961.                   return function (b) {
  1962.                     return function_pipe(bs, Array_append(b))
  1963.                   }
  1964.                 }),
  1965.                 f(i, a)
  1966.               )
  1967.             })
  1968.           }
  1969.         },
  1970.         Array_Functor = { URI: "Array", map: Array_map },
  1971.         Array_Compactable =
  1972.           (flap(Array_Functor),
  1973.           { URI: "Array", compact: Array_compact, separate: Array_separate }),
  1974.         Array_Traversable = {
  1975.           URI: "Array",
  1976.           map: Array_map,
  1977.           reduce: Array_reduce,
  1978.           foldMap: Array_foldMap,
  1979.           reduceRight: Array_reduceRight,
  1980.           traverse: Array_traverse,
  1981.           sequence: Array_sequence,
  1982.         },
  1983.         Option_none =
  1984.           (witherDefault(Array_Traversable, Array_Compactable),
  1985.           wiltDefault(Array_Traversable, Array_Compactable),
  1986.           none),
  1987.         Option_some = some
  1988.       var es6_Option_map = function (f) {
  1989.           return function (fa) {
  1990.             return Option_isNone(fa) ? Option_none : Option_some(f(fa.value))
  1991.           }
  1992.         },
  1993.         Option_of = Option_some,
  1994.         Option_isNone = function (fa) {
  1995.           return "None" === fa._tag
  1996.         },
  1997.         getOrElse = function (onNone) {
  1998.           return function (ma) {
  1999.             return Option_isNone(ma) ? onNone() : ma.value
  2000.           }
  2001.         },
  2002.         fromNullable = function (a) {
  2003.           return null == a ? Option_none : Option_some(a)
  2004.         }
  2005.       Option_of(emptyReadonlyArray)
  2006.       const external_m_namespaceObject = m
  2007.       var external_m_default = __webpack_require__.n(external_m_namespaceObject)
  2008.       const external_rxjs_namespaceObject = rxjs,
  2009.         external_Swal_namespaceObject = Swal
  2010.       var external_Swal_default = __webpack_require__.n(
  2011.         external_Swal_namespaceObject
  2012.       )
  2013.       const forward_to_lib = observer => value => {
  2014.           observer.next(value)
  2015.         },
  2016.         classAttr = classNames => classNames.map(x => `.${x}`).join(""),
  2017.         conditionPresets = {
  2018.           "Default Condition":
  2019.             "(Math.asinh(ratio * 15) / 15 / (private * 1.8 + 1) + Math.log(likes) / 230) / (image + 8)",
  2020.           Newest: "-index",
  2021.           Oldest: "index",
  2022.           "Likes / Views": "ratio",
  2023.           "Most Liked": "likes",
  2024.           "Most Viewed": "views",
  2025.         },
  2026.         getInputValue = event$ =>
  2027.           event$.pipe(
  2028.             (0, external_rxjs_namespaceObject.pluck)("currentTarget"),
  2029.             (0, external_rxjs_namespaceObject.map)(
  2030.               partial_lib(tapIs, HTMLInputElement)
  2031.             ),
  2032.             (0, external_rxjs_namespaceObject.pluck)("value")
  2033.           ),
  2034.         getPageParam = URL_ =>
  2035.           ((URL_, name) => {
  2036.             const param = URL_.searchParams.get(name)
  2037.             return param ? Number.parseInt(param, 10) : 0
  2038.           })(URL_, "page"),
  2039.         reloadImage = image => {
  2040.           const { src } = image
  2041.           ;(image.src = ""), (image.src = src)
  2042.         },
  2043.         removeEmbeddedPage = page => {
  2044.           ;(page.src = ""), page.remove()
  2045.         },
  2046.         getTeaserValue = (info, condition) => {
  2047.           const sortParamPairs = [
  2048.             ["index", info.initialIndex],
  2049.             ["views", info.viewCount],
  2050.             ["likes", info.likeCount],
  2051.             [
  2052.               "ratio",
  2053.               Math.min(info.likeCount / Math.max(1, info.viewCount), 1),
  2054.             ],
  2055.             ["image", info.imageFactor],
  2056.             ["gallery", info.galleryFactor],
  2057.             ["private", info.privateFactor],
  2058.           ]
  2059.           return new Function(
  2060.             ...sortParamPairs.map(([name]) => name),
  2061.             `return (${condition})`
  2062.           )(...sortParamPairs.map(pair => pair[1]))
  2063.         },
  2064.         changeAnchorPageParam = (anchor, value) =>
  2065.           ((anchor, name, value) => {
  2066.             const newURL = new URL(anchor.href, window.location.href)
  2067.             newURL.searchParams.set(name, value), (anchor.href = newURL.href)
  2068.           })(anchor, "page", value.toString()),
  2069.         groupPageItems = pageItems => {
  2070.           const group = document.createElement("li")
  2071.           pageItems[0].before(group),
  2072.             (pageItems[0].style.marginLeft = "0"),
  2073.             pageItems.forEach(item => {
  2074.               item.classList.replace("pager-item", "pager-current")
  2075.             })
  2076.           const groupList = external_m_default()("ul", {
  2077.             style: {
  2078.               display: "inline",
  2079.               backgroundColor: "hsla(0, 0%, 75%, 50%)",
  2080.             },
  2081.             oncreate(vnode) {
  2082.               vnode.dom.append(...pageItems)
  2083.             },
  2084.           })
  2085.           external_m_default().render(group, groupList)
  2086.         },
  2087.         adjustPager = ({ container, pageCount }) => {
  2088.           const currentPage = getPageParam(new URL(window.location.href)),
  2089.             nextPage = currentPage + pageCount
  2090.           var predicate
  2091.           ;[
  2092.             ...[
  2093.               () => [
  2094.                 tapNonNull(container.querySelector(".pager-previous a")),
  2095.                 Math.max(0, currentPage - pageCount),
  2096.               ],
  2097.             ].filter(() => currentPage > 0),
  2098.             ...(() => {
  2099.               const nextPageAnchor = container.querySelector(".pager-next a"),
  2100.                 lastPageAnchor = container.querySelector(".pager-last a")
  2101.               if (lastPageAnchor) {
  2102.                 const reachedLastPage =
  2103.                     getPageParam(
  2104.                       new URL(lastPageAnchor.href, window.location.href)
  2105.                     ) < nextPage,
  2106.                   display = reachedLastPage ? "none" : ""
  2107.                 if (
  2108.                   ((lastPageAnchor.style.display = display),
  2109.                   lib(nextPageAnchor),
  2110.                   (nextPageAnchor.style.display = display),
  2111.                   !reachedLastPage)
  2112.                 )
  2113.                   return [() => [nextPageAnchor, nextPage]]
  2114.               } else if (nextPageAnchor)
  2115.                 return [() => [nextPageAnchor, nextPage]]
  2116.               return []
  2117.             })(),
  2118.           ].forEach(getArgs => changeAnchorPageParam(...getArgs())),
  2119.             function_pipe(
  2120.               Array.from(container.querySelectorAll(".pager-item a")),
  2121.               es6_Array_filter(anchor => {
  2122.                 const page = getPageParam(
  2123.                   new URL(anchor.href, window.location.href)
  2124.                 )
  2125.                 return page >= currentPage && page < nextPage
  2126.               }),
  2127.               ((predicate = currentPageAnchors =>
  2128.                 currentPageAnchors.length > 0),
  2129.               function (a) {
  2130.                 return predicate(a) ? Option_some(a) : Option_none
  2131.               }),
  2132.               es6_Option_map(anchors => [
  2133.                 ...Array.from(container.querySelectorAll(".pager-current")),
  2134.                 ...anchors.map(anchor => tapNonNull(anchor.parentElement)),
  2135.               ]),
  2136.               es6_Option_map(groupPageItems)
  2137.             )
  2138.         },
  2139.         getBrokenImages = () =>
  2140.           getTeaserContainers(document)
  2141.             .flatMap(container => Array.from(container.querySelectorAll("img")))
  2142.             .filter(img => img.complete && 0 === img.naturalWidth),
  2143.         createPreloadPage = (createContainer, parentPageId, url) => {
  2144.           const container = createContainer()
  2145.           return (
  2146.             (container.src = url.toString()),
  2147.             (container.style.display = "none"),
  2148.             container.classList.add(parentPageId),
  2149.             container
  2150.           )
  2151.         },
  2152.         createPreloadUrl = (startURL, page) => {
  2153.           const preloadURL = new URL("", startURL)
  2154.           return (
  2155.             preloadURL.searchParams.set("page", page.toString()), preloadURL
  2156.           )
  2157.         },
  2158.         preloadUrlStream = (startURL, pageCount$) =>
  2159.           pageCount$.pipe(
  2160.             (0, external_rxjs_namespaceObject.scan)(
  2161.               (max, value) => Math.max(max, value),
  2162.               1
  2163.             ),
  2164.             (0, external_rxjs_namespaceObject.startWith)(1),
  2165.             (0, external_rxjs_namespaceObject.bufferCount)(2, 1),
  2166.             (0, external_rxjs_namespaceObject.mergeMap)(([last, current]) =>
  2167.               (0, external_rxjs_namespaceObject.from)(
  2168.                 [...Array(current - last).keys()].map(
  2169.                   i => getPageParam(startURL) + last + i
  2170.                 )
  2171.               )
  2172.             ),
  2173.             (0, external_rxjs_namespaceObject.map)(
  2174.               partial_lib(createPreloadUrl, startURL)
  2175.             )
  2176.           ),
  2177.         trySortTeasers = condition$ =>
  2178.           condition$.pipe(
  2179.             (0, external_rxjs_namespaceObject.map)(condition => [
  2180.               getTeaserContainers(document),
  2181.               condition,
  2182.             ]),
  2183.             (0, external_rxjs_namespaceObject.mergeMap)(x =>
  2184.               (0, external_rxjs_namespaceObject.of)(x).pipe(
  2185.                 (0, external_rxjs_namespaceObject.tap)(
  2186.                   ([containers, condition]) =>
  2187.                     containers.forEach(container =>
  2188.                       ((container, condition) => {
  2189.                         const teaserDivs = Array.from(
  2190.                             container.querySelectorAll(
  2191.                               ".node-teaser, .node-sidebar_teaser, .node-wide_teaser"
  2192.                             )
  2193.                           ),
  2194.                           sortedTeaserCount = container.dataset
  2195.                             .sortedTeaserCount
  2196.                             ? parseInt(container.dataset.sortedTeaserCount, 10)
  2197.                             : 0
  2198.                         teaserDivs
  2199.                           .filter(({ dataset }) => !dataset.initialIndex)
  2200.                           .forEach(({ dataset }, index) => {
  2201.                             dataset.initialIndex = (
  2202.                               sortedTeaserCount + index
  2203.                             ).toString()
  2204.                           }),
  2205.                           (container.dataset.sortedTeaserCount =
  2206.                             teaserDivs.length.toString())
  2207.                         const getNearbyNumber = element => {
  2208.                             return (
  2209.                               (str = element.nextSibling.wholeText.replace(
  2210.                                 /,/g,
  2211.                                 ""
  2212.                               )),
  2213.                               Number.parseFloat(str) *
  2214.                                 (str.includes("k") ? 1e3 : 1)
  2215.                             )
  2216.                             var str
  2217.                           },
  2218.                           nearbyNumberOrZero = element =>
  2219.                             function_pipe(
  2220.                               fromNullable(element),
  2221.                               es6_Option_map(getNearbyNumber),
  2222.                               getOrElse(() => 0)
  2223.                             ),
  2224.                           divValuePairs = teaserDivs
  2225.                             .map(div => ({
  2226.                               initialIndex: parseInt(
  2227.                                 tapNonNull(div.dataset.initialIndex),
  2228.                                 10
  2229.                               ),
  2230.                               viewCount: nearbyNumberOrZero(
  2231.                                 div.querySelector(".glyphicon-eye-open")
  2232.                               ),
  2233.                               likeCount: nearbyNumberOrZero(
  2234.                                 div.querySelector(".glyphicon-heart")
  2235.                               ),
  2236.                               imageFactor: div.querySelector(
  2237.                                 ".field-type-image"
  2238.                               )
  2239.                                 ? 1
  2240.                                 : 0,
  2241.                               galleryFactor: div.querySelector(
  2242.                                 ".glyphicon-th-large"
  2243.                               )
  2244.                                 ? 1
  2245.                                 : 0,
  2246.                               privateFactor: div.querySelector(".private-video")
  2247.                                 ? 1
  2248.                                 : 0,
  2249.                             }))
  2250.                             .map((info, index) => [
  2251.                               teaserDivs[index],
  2252.                               getTeaserValue(info, condition),
  2253.                             ])
  2254.                         divValuePairs.sort(
  2255.                           (itemA, itemB) => itemB[1] - itemA[1]
  2256.                         ),
  2257.                           teaserDivs.forEach(div =>
  2258.                             div.after(document.createElement("span"))
  2259.                           ),
  2260.                           teaserDivs
  2261.                             .map(div => tapNonNull(div.nextSibling))
  2262.                             .forEach((anchor, index) =>
  2263.                               anchor.replaceWith(divValuePairs[index][0])
  2264.                             )
  2265.                       })(container, condition)
  2266.                     )
  2267.                 ),
  2268.                 (0, external_rxjs_namespaceObject.catchError)(
  2269.                   error => (
  2270.                     external_Swal_default().fire(
  2271.                       "Sorting Failed",
  2272.                       `An error accured while sorting: ${error}`
  2273.                     ),
  2274.                     external_log_namespaceObject.error(error),
  2275.                     external_rxjs_namespaceObject.EMPTY
  2276.                   )
  2277.                 )
  2278.               )
  2279.             ),
  2280.             (0, external_rxjs_namespaceObject.map)(([containers]) => ({
  2281.               containersCount: containers.length,
  2282.             }))
  2283.           ),
  2284.         initParent = async () => {
  2285.           if (0 === getTeaserContainers(document).length) return
  2286.           const initialCondition = tapNonNull(
  2287.               await GM.getValue(
  2288.                 "sortValue",
  2289.                 conditionPresets["Default Condition"]
  2290.               )
  2291.             ),
  2292.             pageCount = tapNonNull(await GM.getValue("pageCount", 1)),
  2293.             haveMorePages = Boolean(
  2294.               document.querySelector(".pager") &&
  2295.                 !document.querySelector("#comments")
  2296.             ),
  2297.             sortComponent = new (class {
  2298.               constructor(initialCondition, initialPageCount) {
  2299.                 ;(this.conditionInputInput$ =
  2300.                   new external_rxjs_namespaceObject.Subject()),
  2301.                   (this.conditionInputChange$ =
  2302.                     new external_rxjs_namespaceObject.Subject()),
  2303.                   (this.conditionInputKeydown$ =
  2304.                     new external_rxjs_namespaceObject.Subject()),
  2305.                   (this.sortButtonClick$ =
  2306.                     new external_rxjs_namespaceObject.Subject()),
  2307.                   (this.presetSelectChange$ =
  2308.                     new external_rxjs_namespaceObject.Subject()),
  2309.                   (this.pageCountInputInput$ =
  2310.                     new external_rxjs_namespaceObject.Subject()),
  2311.                   (this.pageCountInputChange$ =
  2312.                     new external_rxjs_namespaceObject.Subject()),
  2313.                   (this.conditionInputEnterDown$ =
  2314.                     this.conditionInputKeydown$.pipe(
  2315.                       (0, external_rxjs_namespaceObject.filter)(
  2316.                         e => "Enter" === e.key
  2317.                       )
  2318.                     )),
  2319.                   (this.conditionChange$ = (0,
  2320.                   external_rxjs_namespaceObject.merge)(
  2321.                     this.conditionInputEnterDown$,
  2322.                     this.presetSelectChange$,
  2323.                     this.conditionInputChange$
  2324.                   )),
  2325.                   (this.sort$ = (0, external_rxjs_namespaceObject.merge)(
  2326.                     this.sortButtonClick$,
  2327.                     this.conditionInputEnterDown$,
  2328.                     this.presetSelectChange$
  2329.                   ).pipe(
  2330.                     (0, external_rxjs_namespaceObject.map)(
  2331.                       () => this.state.condition
  2332.                     )
  2333.                   )),
  2334.                   (this.condition$ = this.conditionChange$.pipe(
  2335.                     (0, external_rxjs_namespaceObject.startWith)(void 0),
  2336.                     (0, external_rxjs_namespaceObject.map)(
  2337.                       () => this.state.condition
  2338.                     )
  2339.                   )),
  2340.                   (this.pageCount$ = this.pageCountInputChange$.pipe(
  2341.                     (0, external_rxjs_namespaceObject.startWith)(void 0),
  2342.                     (0, external_rxjs_namespaceObject.map)(
  2343.                       () => this.state.pageCount
  2344.                     )
  2345.                   )),
  2346.                   (this.state = {
  2347.                     condition: initialCondition,
  2348.                     pageCount: initialPageCount,
  2349.                     loadedPageCount: 0,
  2350.                   }),
  2351.                   (0, external_rxjs_namespaceObject.merge)(
  2352.                     this.conditionInputInput$.pipe(
  2353.                       getInputValue,
  2354.                       (0, external_rxjs_namespaceObject.tap)(value => {
  2355.                         this.state.condition = value
  2356.                       })
  2357.                     ),
  2358.                     (0, external_rxjs_namespaceObject.merge)(
  2359.                       this.conditionChange$,
  2360.                       this.presetSelectChange$.pipe(
  2361.                         (0, external_rxjs_namespaceObject.tap)(e => {
  2362.                           this.state.condition = tapIs(
  2363.                             HTMLSelectElement,
  2364.                             e.currentTarget
  2365.                           ).value
  2366.                         })
  2367.                       )
  2368.                     ).pipe(
  2369.                       (0, external_rxjs_namespaceObject.map)(
  2370.                         () => this.state.condition
  2371.                       ),
  2372.                       (0, external_rxjs_namespaceObject.tap)(value =>
  2373.                         GM.setValue("sortValue", value)
  2374.                       )
  2375.                     ),
  2376.                     this.pageCountInputInput$.pipe(
  2377.                       getInputValue,
  2378.                       (0, external_rxjs_namespaceObject.map)(value =>
  2379.                         Number.parseInt(value, 10)
  2380.                       ),
  2381.                       (0, external_rxjs_namespaceObject.tap)(pageCount => {
  2382.                         this.state.pageCount = pageCount
  2383.                       })
  2384.                     ),
  2385.                     this.pageCountInputChange$.pipe(
  2386.                       (0, external_rxjs_namespaceObject.tap)(() =>
  2387.                         GM.setValue("pageCount", this.state.pageCount)
  2388.                       )
  2389.                     )
  2390.                   ).subscribe()
  2391.               }
  2392.               view() {
  2393.                 const commonStyle = { margin: "5px 2px" },
  2394.                   presetOptions = Object.entries(conditionPresets).map(
  2395.                     ([name, value]) =>
  2396.                       external_m_default()("option", { value }, name)
  2397.                   ),
  2398.                   uiChildren = {
  2399.                     conditionInput: external_m_default()(
  2400.                       `input${classAttr(["form-control", "input-sm"])}`,
  2401.                       {
  2402.                         size: 60,
  2403.                         value: this.state.condition,
  2404.                         style: commonStyle,
  2405.                         list: "iwara-custom-sort-conditions",
  2406.                         oninput: forward_to_lib(this.conditionInputInput$),
  2407.                         onchange: forward_to_lib(this.conditionInputChange$),
  2408.                         onkeydown: forward_to_lib(this.conditionInputKeydown$),
  2409.                       }
  2410.                     ),
  2411.                     conditionDatalist: external_m_default()(
  2412.                       "datalist",
  2413.                       { id: "iwara-custom-sort-conditions" },
  2414.                       presetOptions
  2415.                     ),
  2416.                     presetSelect: external_m_default()(
  2417.                       `select${classAttr(["btn", "btn-sm", "btn-info"])}`,
  2418.                       {
  2419.                         onupdate: vnode => {
  2420.                           tapIs(HTMLSelectElement, vnode.dom).selectedIndex = 0
  2421.                         },
  2422.                         style: { width: "95px", ...commonStyle },
  2423.                         onchange: forward_to_lib(this.presetSelectChange$),
  2424.                       },
  2425.                       [
  2426.                         external_m_default()(
  2427.                           "option",
  2428.                           { hidden: !0 },
  2429.                           "Presets"
  2430.                         ),
  2431.                         ...presetOptions,
  2432.                       ]
  2433.                     ),
  2434.                     sortButton: external_m_default()(
  2435.                       `button${classAttr(["btn", "btn-sm", "btn-primary"])}`,
  2436.                       {
  2437.                         style: commonStyle,
  2438.                         onclick: forward_to_lib(this.sortButtonClick$),
  2439.                       },
  2440.                       "Sort"
  2441.                     ),
  2442.                     label1: external_m_default()(
  2443.                       `label${classAttr(["text-primary"])}`,
  2444.                       { style: commonStyle },
  2445.                       "load"
  2446.                     ),
  2447.                     pageCountInput: external_m_default()(
  2448.                       `input${classAttr(["form-control", "input-sm"])}`,
  2449.                       {
  2450.                         type: "number",
  2451.                         value: this.state.pageCount,
  2452.                         min: 1,
  2453.                         max: 500,
  2454.                         step: 1,
  2455.                         style: { width: "7rem", ...commonStyle },
  2456.                         oninput: forward_to_lib(this.pageCountInputInput$),
  2457.                         onchange: forward_to_lib(this.pageCountInputChange$),
  2458.                       }
  2459.                     ),
  2460.                     label2: external_m_default()(
  2461.                       `label${classAttr(["text-primary"])}`,
  2462.                       { style: commonStyle },
  2463.                       "pages. "
  2464.                     ),
  2465.                     statusLabel: external_m_default()(
  2466.                       `label${classAttr(["text-primary"])}`,
  2467.                       { style: commonStyle },
  2468.                       this.state.loadedPageCount < this.state.pageCount
  2469.                         ? `${this.state.loadedPageCount} of ${this.state.pageCount} pages done`
  2470.                         : "All pages done"
  2471.                     ),
  2472.                   }
  2473.                 return external_m_default()(
  2474.                   `div${classAttr(["form-inline", "container"])}`,
  2475.                   { style: { display: "inline-block" } },
  2476.                   Object.values(uiChildren)
  2477.                 )
  2478.               }
  2479.               addLoadedPageCount() {
  2480.                 ;(this.state.loadedPageCount += 1),
  2481.                   external_m_default().redraw()
  2482.               }
  2483.             })(initialCondition, pageCount),
  2484.             preloadUrl$ = (
  2485.               haveMorePages
  2486.                 ? sortComponent.pageCount$
  2487.                 : (0, external_rxjs_namespaceObject.of)(1)
  2488.             ).pipe(
  2489.               partial_lib(preloadUrlStream, new URL(window.location.href))
  2490.             ),
  2491.             channel = new broadcast_channel_BroadcastChannel(scriptIdentifier),
  2492.             parentPageId = `t-${performance.now().toString()}`,
  2493.             pageLoad$ = (0, external_rxjs_namespaceObject.fromEvent)(
  2494.               channel,
  2495.               "message"
  2496.             ).pipe(
  2497.               (0, external_rxjs_namespaceObject.filter)(
  2498.                 data => data.parentPageId === parentPageId
  2499.               )
  2500.             ),
  2501.             teaserPageLoad$ = pageLoad$.pipe(
  2502.               (0, external_rxjs_namespaceObject.filter)(
  2503.                 message => message.hasTeasers
  2504.               )
  2505.             ),
  2506.             pageFromUrl = new Map(),
  2507.             unsortedTeasers$ = teaserPageLoad$.pipe(
  2508.               (0, external_rxjs_namespaceObject.mapTo)(void 0),
  2509.               (0, external_rxjs_namespaceObject.startWith)(void 0)
  2510.             ),
  2511.             clonedClass = `${scriptIdentifier}-cloned`,
  2512.             allStreams = {
  2513.               adjustPager$: sortComponent.pageCount$.pipe(
  2514.                 (0, external_rxjs_namespaceObject.mergeMap)(count =>
  2515.                   (0, external_rxjs_namespaceObject.from)(
  2516.                     document.querySelectorAll(`.pager:not(.${clonedClass})`)
  2517.                   ).pipe(
  2518.                     (0, external_rxjs_namespaceObject.tap)(pager => {
  2519.                       pager.style.display = "none"
  2520.                     }),
  2521.                     (0, external_rxjs_namespaceObject.map)(pager => {
  2522.                       const clonedPager = tapIs(
  2523.                         HTMLElement,
  2524.                         pager.cloneNode(!0)
  2525.                       )
  2526.                       return (
  2527.                         (clonedPager.style.display = ""), [pager, clonedPager]
  2528.                       )
  2529.                     }),
  2530.                     (0, external_rxjs_namespaceObject.tap)(
  2531.                       ([pager, clonedPager]) => {
  2532.                         const sibling = pager.previousElementSibling
  2533.                         sibling && sibling.matches(`.${clonedClass}`)
  2534.                           ? sibling.replaceWith(clonedPager)
  2535.                           : pager.before(clonedPager)
  2536.                       }
  2537.                     ),
  2538.                     (0, external_rxjs_namespaceObject.tap)(
  2539.                       ([, clonedPager]) => {
  2540.                         clonedPager.classList.add(clonedClass)
  2541.                       }
  2542.                     ),
  2543.                     (0, external_rxjs_namespaceObject.map)(
  2544.                       ([, clonedPager]) => ({
  2545.                         container: clonedPager,
  2546.                         pageCount: count,
  2547.                       })
  2548.                     )
  2549.                   )
  2550.                 ),
  2551.                 (0, external_rxjs_namespaceObject.tap)(adjustPager)
  2552.               ),
  2553.               logPageLoad$: pageLoad$.pipe(
  2554.                 (0, external_rxjs_namespaceObject.tap)(
  2555.                   external_log_namespaceObject.info
  2556.                 )
  2557.               ),
  2558.               reloadBrokenImages$: unsortedTeasers$.pipe(
  2559.                 (0, external_rxjs_namespaceObject.mergeMap)(() =>
  2560.                   (0, external_rxjs_namespaceObject.timer)(0, 8e3).pipe(
  2561.                     (0, external_rxjs_namespaceObject.take)(2)
  2562.                   )
  2563.                 ),
  2564.                 (0, external_rxjs_namespaceObject.auditTime)(6e3),
  2565.                 (0, external_rxjs_namespaceObject.map)(getBrokenImages),
  2566.                 (0, external_rxjs_namespaceObject.tap)(images =>
  2567.                   images.forEach(reloadImage)
  2568.                 ),
  2569.                 (0, external_rxjs_namespaceObject.map)(
  2570.                   images => `Reload ${images.length} broken image(s)`
  2571.                 ),
  2572.                 (0, external_rxjs_namespaceObject.tap)(
  2573.                   external_log_namespaceObject.info
  2574.                 )
  2575.               ),
  2576.               sortTeasers$: (0, external_rxjs_namespaceObject.merge)(
  2577.                 unsortedTeasers$.pipe(
  2578.                   (0, external_rxjs_namespaceObject.withLatestFrom)(
  2579.                     sortComponent.condition$
  2580.                   ),
  2581.                   (0, external_rxjs_namespaceObject.map)(
  2582.                     ([, condition]) => condition
  2583.                   ),
  2584.                   (0, external_rxjs_namespaceObject.tap)(() =>
  2585.                     sortComponent.addLoadedPageCount()
  2586.                   )
  2587.                 ),
  2588.                 sortComponent.sort$
  2589.               ).pipe(
  2590.                 trySortTeasers,
  2591.                 (0, external_rxjs_namespaceObject.map)(
  2592.                   result => `${result.containersCount} containers sorted`
  2593.                 ),
  2594.                 (0, external_rxjs_namespaceObject.tap)(
  2595.                   external_log_namespaceObject.info
  2596.                 )
  2597.               ),
  2598.               removeLoadedPage$: pageLoad$.pipe(
  2599.                 (0, external_rxjs_namespaceObject.map)(({ url }) => ({
  2600.                   url,
  2601.                   container: pageFromUrl.get(url),
  2602.                 })),
  2603.                 (0, external_rxjs_namespaceObject.tap)(({ url }) =>
  2604.                   pageFromUrl.delete(url)
  2605.                 ),
  2606.                 (0, external_rxjs_namespaceObject.pluck)("container"),
  2607.                 (0, external_rxjs_namespaceObject.map)(tapNonNull),
  2608.                 (0, external_rxjs_namespaceObject.tap)(removeEmbeddedPage)
  2609.               ),
  2610.               addHiddenPreload$: (0, external_rxjs_namespaceObject.zip)(
  2611.                 preloadUrl$,
  2612.                 teaserPageLoad$.pipe(
  2613.                   (0, external_rxjs_namespaceObject.scan)(
  2614.                     countDown => (countDown > 0 ? countDown - 1 : countDown),
  2615.                     5
  2616.                   ),
  2617.                   (0, external_rxjs_namespaceObject.map)(countDown =>
  2618.                     countDown > 0 ? 2 : 1
  2619.                   ),
  2620.                   (0, external_rxjs_namespaceObject.startWith)(2),
  2621.                   (0, external_rxjs_namespaceObject.mergeMap)(createPageCount =>
  2622.                     (0, external_rxjs_namespaceObject.of)(
  2623.                       ...Array.from({ length: createPageCount }, () => {})
  2624.                     )
  2625.                   )
  2626.                 )
  2627.               ).pipe(
  2628.                 (0, external_rxjs_namespaceObject.map)(([url]) => [
  2629.                   url,
  2630.                   () => {
  2631.                     return (
  2632.                       (userAgent = window.navigator.userAgent),
  2633.                       document.createElement(
  2634.                         userAgent.indexOf("Firefox") > -1 ? "embed" : "iframe"
  2635.                       )
  2636.                     )
  2637.                     var userAgent
  2638.                   },
  2639.                 ]),
  2640.                 (0, external_rxjs_namespaceObject.map)(
  2641.                   ([url, createContainer]) => [
  2642.                     url.toString(),
  2643.                     createPreloadPage(createContainer, parentPageId, url),
  2644.                   ]
  2645.                 ),
  2646.                 (0, external_rxjs_namespaceObject.tap)(entry =>
  2647.                   pageFromUrl.set(...entry)
  2648.                 ),
  2649.                 (0, external_rxjs_namespaceObject.tap)(([, container]) =>
  2650.                   document.body.append(container)
  2651.                 )
  2652.               ),
  2653.             }
  2654.           ;(0, external_rxjs_namespaceObject.merge)(
  2655.             ...Object.values(allStreams)
  2656.           ).subscribe()
  2657.           const sortComponentContainer = document.createElement("div")
  2658.           tapNonNull(document.querySelector("#user-links")).after(
  2659.             sortComponentContainer
  2660.           ),
  2661.             external_m_default().mount(sortComponentContainer, sortComponent),
  2662.             external_log_namespaceObject.debug(await GM.listValues())
  2663.         },
  2664.         initialize = async () => {
  2665.           const isParent = window === window.parent
  2666.           external_log_namespaceObject.debug(
  2667.             `${isParent ? "Parent" : "Child"}: ${window.location.href}`
  2668.           ),
  2669.             await (isParent
  2670.               ? initParent()
  2671.               : (async () => {
  2672.                   var _a
  2673.                   const teaserContainers = getTeaserContainers(document),
  2674.                     channel = new broadcast_channel_BroadcastChannel(
  2675.                       scriptIdentifier
  2676.                     ),
  2677.                     hasTeasers = teaserContainers.length > 0,
  2678.                     message = {
  2679.                       url: window.location.href,
  2680.                       parentPageId: Array.from(
  2681.                         tapNonNull(window.frameElement).classList
  2682.                       ).filter(x => x.startsWith("t-"))[0],
  2683.                       hasTeasers,
  2684.                     }
  2685.                   hasTeasers &&
  2686.                     (await delay_default()(500),
  2687.                     ((children, parents) => {
  2688.                       for (
  2689.                         let i = 0, j = 0;
  2690.                         i < parents.length && j < children.length;
  2691.                         i += 1
  2692.                       ) {
  2693.                         const parent = parents[i],
  2694.                           child = children[j]
  2695.                         parent.className === child.className &&
  2696.                           ((child.className = ""),
  2697.                           parent.append(child),
  2698.                           (j += 1))
  2699.                       }
  2700.                     })(
  2701.                       teaserContainers,
  2702.                       function_pipe(
  2703.                         null === (_a = window.parent) || void 0 === _a
  2704.                           ? void 0
  2705.                           : _a.document,
  2706.                         x => (x ? getTeaserContainers(x) : [])
  2707.                       )
  2708.                     )),
  2709.                     channel.postMessage(message)
  2710.                 })())
  2711.         }
  2712.       ;(async () => {
  2713.         external_log_namespaceObject.setLevel("debug")
  2714.         try {
  2715.           await initialize()
  2716.         } catch (error) {
  2717.           external_log_namespaceObject.error(error)
  2718.         }
  2719.       })()
  2720.     })()
  2721. })()

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址