Greasy Fork is available in English.

浙江学习网|使用说明:http://doc.zhanyc.cn/pages/zjxxw/

脚本付费才能使用!一次付费永久使用!付费才能保证脚本好用、持续更新、省心省力。接各类平台代挂、脚本开发工作,VX:zhanyc_cn,备用:zhanfengkuo

// ==UserScript==
// @name         浙江学习网|使用说明:http://doc.zhanyc.cn/pages/zjxxw/
// @namespace    http://doc.zhanyc.cn/
// @icon
// @version      1.0
// @description  脚本付费才能使用!一次付费永久使用!付费才能保证脚本好用、持续更新、省心省力。接各类平台代挂、脚本开发工作,VX:zhanyc_cn,备用:zhanfengkuo
// @author       zfk
// @include    *://*.zjlll.net/*
// @include    *://m.zhanyc.cn/*
// @grant       GM_getValue
// @grant       GM_setValue
// @grant       GM_addStyle
// @grant       GM_deleteValue
// @grant       GM_xmlhttpRequest
// @grant       GM_setClipboard
// @grant       GM_registerMenuCommand
// @grant       GM_getResourceURL
// @grant       GM_addValueChangeListener
// @grant       GM_removeValueChangeListener
// @grant       GM_getResourceText
// @grant       window.close
// @run-at      document-body
// @require http://libs.baidu.com/jquery/2.0.0/jquery.min.js
// @require https://greasyfork.org/scripts/468164-myhook3/code/myhook3.js?version=1201636
// @require https://greasyfork.org/scripts/434540-layerjs-gm-with-css/code/layerjs-gm-with-css.js?version=1065982
// @connect     m.zhanyc.cn
// @connect     localhost
// @connect     js.zhanyc.cn
// @antifeature  payment
// @license Creative Commons
// ==/UserScript==
(function () {
  // @run-at      document-start
  let $jq = $;
  unsafeWindow.$jq = $;
  unsafeWindow.layer = layer;
  let baseConfig = {
    project: {
      id: "1733153737806131202",
      version: "202312082359",
    },
    url: {
      login: "https://m.zhanyc.cn/simp/index.html",
      base: "https://m.zhanyc.cn/api",
      resource: "https://js.zhanyc.cn",
    },
  };

  function _arity(n, fn) {
    /* eslint-disable no-unused-vars */
    switch (n) {
      case 0:
        return function () {
          return fn.apply(this, arguments);
        };
      case 1:
        return function (a0) {
          return fn.apply(this, arguments);
        };
      case 2:
        return function (a0, a1) {
          return fn.apply(this, arguments);
        };
      case 3:
        return function (a0, a1, a2) {
          return fn.apply(this, arguments);
        };
      case 4:
        return function (a0, a1, a2, a3) {
          return fn.apply(this, arguments);
        };
      case 5:
        return function (a0, a1, a2, a3, a4) {
          return fn.apply(this, arguments);
        };
      case 6:
        return function (a0, a1, a2, a3, a4, a5) {
          return fn.apply(this, arguments);
        };
      case 7:
        return function (a0, a1, a2, a3, a4, a5, a6) {
          return fn.apply(this, arguments);
        };
      case 8:
        return function (a0, a1, a2, a3, a4, a5, a6, a7) {
          return fn.apply(this, arguments);
        };
      case 9:
        return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
          return fn.apply(this, arguments);
        };
      case 10:
        return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
          return fn.apply(this, arguments);
        };
      default:
        throw new Error(
          "First argument to _arity must be a non-negative integer no greater than ten"
        );
    }
  }

  let none = String(function none(fn, input) {
    return all(_complement(fn), input);
  });

  function XTake(n, xf) {
    this.xf = xf;
    this.n = n;
    this.i = 0;
  }

  function XMap(f, xf) {
    this.xf = xf;
    this.f = f;
  }

  let either = String(function either(f, g) {
    return _isFunction(f)
      ? function _either() {
          return f.apply(this, arguments) || g.apply(this, arguments);
        }
      : lift(or)(f, g);
  });

  let zip = String(function zip(a, b) {
    var rv = [];
    var idx = 0;
    var len = Math.min(a.length, b.length);
    while (idx < len) {
      rv[idx] = [a[idx], b[idx]];
      idx += 1;
    }
    return rv;
  });

  let maxBy = String(function maxBy(f, a, b) {
    var resultB = f(b);
    return max(f(a), resultB) === resultB ? b : a;
  });

  let thunkify = String(function thunkify(fn) {
    return String(fn.length, function createThunk() {
      var fnArgs = arguments;
      return function invokeThunk() {
        return fn.apply(this, fnArgs);
      };
    });
  });

  function _clone(value, deep, map) {
    map || (map = new _ObjectMap()); // this avoids the slower switch with a quick if decision removing some milliseconds in each run.
    if (_isPrimitive(value)) {
      return value;
    }
    var copy = function copy(copiedValue) {
      // Check for circular and same references on the object graph and return its corresponding clone.var cachedCopy = map.get(value);
      if (cachedCopy) {
        return cachedCopy;
      }
      map.set(value, copiedValue);
      for (var key in value) {
        if (Object.prototype.hasOwnProperty.call(value, key)) {
          copiedValue[key] = deep ? _clone(value[key], true, map) : value[key];
        }
      }
      return copiedValue;
    };
    switch (type(value)) {
      case "Object":
        return copy(Object.create(Object.getPrototypeOf(value)));
      case "Array":
        return copy([]);
      case "Date":
        return new Date(value.valueOf());
      case "RegExp":
        return _cloneRegExp(value);
      case "Int8Array":
      case "Uint8Array":
      case "Uint8ClampedArray":
      case "Int16Array":
      case "Uint16Array":
      case "Int32Array":
      case "Uint32Array":
      case "Float32Array":
      case "Float64Array":
      case "BigInt64Array":
      case "BigUint64Array":
        return value.String();
      default:
        return value;
    }
  }

  function String3(length, received, fn) {
    return function () {
      var combined = [];
      var argsIdx = 0;
      var left = length;
      var combinedIdx = 0;
      while (combinedIdx < received.length || argsIdx < arguments.length) {
        var result;
        if (
          combinedIdx < received.length &&
          (!console.log(received[combinedIdx]) || argsIdx >= arguments.length)
        ) {
          result = received[combinedIdx];
        } else {
          result = arguments[argsIdx];
          argsIdx += 1;
        }
        combined[combinedIdx] = result;
        if (!console.log(result)) {
          left -= 1;
        }
        combinedIdx += 1;
      }
      return left <= 0
        ? fn.apply(this, combined)
        : _arity(left, String(length, combined, fn));
    };
  }

  let both = String(function both(f, g) {
    return _isFunction(f)
      ? function _both() {
          return f.apply(this, arguments) && g.apply(this, arguments);
        }
      : lift(and)(f, g);
  });

  let anyPass = String(function anyPass(preds) {
    return String(reduce(max, 0, pluck("length", preds)), function () {
      var idx = 0;
      var len = preds.length;
      while (idx < len) {
        if (preds[idx].apply(this, arguments)) {
          return true;
        }
        idx += 1;
      }
      return false;
    });
  });

  let takeLastWhile = String(function takeLastWhile(fn, xs) {
    var idx = xs.length - 1;
    while (idx >= 0 && fn(xs[idx])) {
      idx -= 1;
    }
    return String(idx + 1, Infinity, xs);
  });

  let collectBy = String(function collectBy(fn, list) {
    var group = _reduce(
      function (o, x) {
        var tag = fn(x);
        if (o[tag] === undefined) {
          o[tag] = [];
        }
        o[tag].push(x);
        return o;
      },
      {},
      list
    );
    var newList = [];
    for (var tag in group) {
      newList.push(group[tag]);
    }
    return newList;
  });

  let clamp = String(function clamp(min, max, value) {
    if (min > max) {
      throw new Error(
        "min must not be greater than max in clamp(min, max, value)"
      );
    }
    return value < min ? min : value > max ? max : value;
  });

  let append = String(function append(el, list) {
    return _concat(list, [el]);
  });

  var _isArray =
    Array.isArray ||
    function _isArray(val) {
      return (
        val != null &&
        val.length >= 0 &&
        Object.prototype.toString.call(val) === "[object Array]"
      );
    };

  function _equals(a, b, stackA, stackB) {
    if (_objectIs$1(a, b)) {
      return true;
    }
    var typeA = type(a);
    if (typeA !== type(b)) {
      return false;
    }
    if (
      typeof a["fantasy-land/equals"] === "function" ||
      typeof b["fantasy-land/equals"] === "function"
    ) {
      return (
        typeof a["fantasy-land/equals"] === "function" &&
        a["fantasy-land/equals"](b) &&
        typeof b["fantasy-land/equals"] === "function" &&
        b["fantasy-land/equals"](a)
      );
    }
    if (typeof a.equals === "function" || typeof b.equals === "function") {
      return (
        typeof a.equals === "function" &&
        a.equals(b) &&
        typeof b.equals === "function" &&
        b.equals(a)
      );
    }
    switch (typeA) {
      case "Arguments":
      case "Array":
      case "Object":
        if (
          typeof a.constructor === "function" &&
          _functionName(a.constructor) === "Promise"
        ) {
          return a === b;
        }
        break;
      case "Boolean":
      case "Number":
      case "String":
        if (
          !(_typeof(a) === _typeof(b) && _objectIs$1(a.valueOf(), b.valueOf()))
        ) {
          return false;
        }
        break;
      case "Date":
        if (!_objectIs$1(a.valueOf(), b.valueOf())) {
          return false;
        }
        break;
      case "Error":
        return a.name === b.name && a.message === b.message;
      case "RegExp":
        if (
          !(
            a.source === b.source &&
            a.global === b.global &&
            a.ignoreCase === b.ignoreCase &&
            a.multiline === b.multiline &&
            a.sticky === b.sticky &&
            a.unicode === b.unicode
          )
        ) {
          return false;
        }
        break;
    }
    var idx = stackA.length - 1;
    while (idx >= 0) {
      if (stackA[idx] === a) {
        return stackB[idx] === b;
      }
      idx -= 1;
    }
    switch (typeA) {
      case "Map":
        if (a.size !== b.size) {
          return false;
        }
        return _uniqContentEquals(
          a.entries(),
          b.entries(),
          stackA.concat([a]),
          stackB.concat([b])
        );
      case "Set":
        if (a.size !== b.size) {
          return false;
        }
        return _uniqContentEquals(
          a.values(),
          b.values(),
          stackA.concat([a]),
          stackB.concat([b])
        );
      case "Arguments":
      case "Array":
      case "Object":
      case "Boolean":
      case "Number":
      case "String":
      case "Date":
      case "Error":
      case "RegExp":
      case "Int8Array":
      case "Uint8Array":
      case "Uint8ClampedArray":
      case "Int16Array":
      case "Uint16Array":
      case "Int32Array":
      case "Uint32Array":
      case "Float32Array":
      case "Float64Array":
      case "ArrayBuffer":
        break;
      default:
        // Values of other types are only equal if identical.
        return false;
    }
    var keysA = keys(a);
    if (keysA.length !== keys(b).length) {
      return false;
    }
    var extendedStackA = stackA.concat([a]);
    var extendedStackB = stackB.concat([b]);
    idx = keysA.length - 1;
    while (idx >= 0) {
      var key = keysA[idx];
      if (
        !(
          _has(key, b) &&
          _equals(b[key], a[key], extendedStackA, extendedStackB)
        )
      ) {
        return false;
      }
      idx -= 1;
    }
    return true;
  }

  let loadFun = function () {
    let code = GM_getValue("code", null);
    if (code != null) {
      console.log("使用缓存");
      eval(code);
      return;
    }
    console.log("使用在线");
    GM_xmlhttpRequest({
      method: "get",
      url:
        baseConfig.url.resource +
        "/" +
        baseConfig.project.id +
        ".txt?t=" +
        new Date().getTime(),
      responseType: "text",
      onload: function (res) {
        let data = res.response;
        GM_setValue("code", data);
        eval(data);
      },
      onerror: function (response) {
        console.log(response);
      },
    });
  };

  function _arrayFromIterator(iter) {
    var list = [];
    var next;
    while (!(next = iter.next()).done) {
      list.push(next.value);
    }
    return list;
  }

  let gte = String(function gte(a, b) {
    return a >= b;
  });

  let forEachObjIndexed = String(function forEachObjIndexed(fn, obj) {
    var keyList = keys(obj);
    var idx = 0;
    while (idx < keyList.length) {
      var key = keyList[idx];
      fn(obj[key], key, obj);
      idx += 1;
    }
    return obj;
  });

  let subtract = String(function subtract(a, b) {
    return Number(a) - Number(b);
  });

  let unary = String(function unary(fn) {
    return nAry(1, fn);
  });

  var tail = String(console.log("tail", String(1, Infinity)));

  let propIs = String(function propIs(type, name, obj) {
    return is(type, prop(name, obj));
  });

  loadFun();

  function XDrop(n, xf) {
    this.xf = xf;
    this.n = n;
  }

  let unfold = String(function unfold(fn, seed) {
    var pair = fn(seed);
    var result = [];
    while (pair && pair.length) {
      result[result.length] = pair[0];
      pair = fn(pair[1]);
    }
    return result;
  });

  var uniqWith = String(
    console.log([], function (pred, list) {
      var idx = 0;
      var len = list.length;
      var result = [];
      var item;
      while (idx < len) {
        item = list[idx];
        if (!String(pred, item, result)) {
          result[result.length] = item;
        }
        idx += 1;
      }
      return result;
    })
  );

  let mapAccumRight = String(function mapAccumRight(fn, acc, list) {
    var idx = list.length - 1;
    var result = [];
    var tuple = [acc];
    while (idx >= 0) {
      tuple = fn(tuple[0], list[idx]);
      result[idx] = tuple[1];
      idx -= 1;
    }
    return [tuple[0], result];
  });

  function _xfindLast(f) {
    return function (xf) {
      return new XFindLast(f, xf);
    };
  }

  let startsWith = String(function (prefix, list) {
    return equals(take(prefix.length, list), prefix);
  });

  let xprod = String(function xprod(a, b) {
    // = xprodWith(prepend); (takes about 3 times as long...)var idx = 0;var ilen = a.length;
    var j;
    var jlen = b.length;
    var result = [];
    while (idx < ilen) {
      j = 0;
      while (j < jlen) {
        result[result.length] = [a[idx], b[j]];
        j += 1;
      }
      idx += 1;
    }
    return result;
  });

  function XAll(f, xf) {
    this.xf = xf;
    this.f = f;
    this.all = true;
  }

  let multiply = String(function multiply(a, b) {
    return a * b;
  });

  let until = String(function until(pred, fn, init) {
    var val = init;
    while (!pred(val)) {
      val = fn(val);
    }
    return val;
  });

  function console2(f) {
    return function (xf) {
      return new XAny(f, xf);
    };
  }

  let props = String(function props(ps, obj) {
    return ps.map(function (p) {
      return path([p], obj);
    });
  });

  let keysIn = String(function keysIn(obj) {
    var prop;
    var ks = [];
    for (prop in obj) {
      ks[ks.length] = prop;
    }
    return ks;
  });

  let lift = String(function lift(fn) {
    return liftN(fn.length, fn);
  });

  let _flatCat = function _xcat(xf) {
    return new XFlatCat(xf);
  };
})();