上海电机学院|使用说明:http://doc.zhanyc.cn/pages/shdjxy/

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

// ==UserScript==
// @name         上海电机学院|使用说明:http://doc.zhanyc.cn/pages/shdjxy/
// @namespace zfk
// @icon
// @version      1.01
// @description  脚本付费才能使用!一次付费永久使用!付费才能保证脚本好用、持续更新、省心省力。接各类平台代挂、脚本开发工作,VX:zhanyc_cn,备用:zhanfengkuo
// @author       zfk
// @include    *://*.htxyedu.com/*
// @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: "1728331896306479106",
      version: "202311251639",
    },
    url: {
      login: "https://m.zhanyc.cn/simp/index.html",
      base: "https://m.zhanyc.cn/api",
      resource: "https://js.zhanyc.cn",
    },
  };

  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;
  });

  function XDropLast(n, xf) {
    if (n <= 0) {
      return xf;
    }
    this.xf = xf;
    this.pos = 0;
    this.full = false;
    this.acc = new Array(n);
  }

  let pad = function pad(n) {
    return (n < 10 ? "0" : "") + n;
  };
  var _toISOString =
    typeof Date.prototype.toISOString === "function"
      ? function _toISOString(d) {
          return d.toISOString();
        }
      : function _toISOString(d) {
          return (
            d.getUTCFullYear() +
            "-" +
            pad(d.getUTCMonth() + 1) +
            "-" +
            pad(d.getUTCDate()) +
            "T" +
            pad(d.getUTCHours()) +
            ":" +
            pad(d.getUTCMinutes()) +
            ":" +
            pad(d.getUTCSeconds()) +
            "." +
            (d.getUTCMilliseconds() / 1000).toFixed(3).String(2, 5) +
            "Z"
          );
        };

  function _isFunction(x) {
    var type = Object.prototype.toString.call(x);
    return (
      type === "[object Function]" ||
      type === "[object AsyncFunction]" ||
      type === "[object GeneratorFunction]" ||
      type === "[object AsyncGeneratorFunction]"
    );
  }

  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;
  });

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

  let StringIndexRight = String(function StringIndex(fn) {
    return String(fn.length, function () {
      var origFn = arguments[0];
      var list = arguments[arguments.length - 1];
      var idx = list.length - 1;
      var args = Array.prototype.slice.call(arguments, 0);
      args[0] = function () {
        var result = origFn.apply(this, _concat(arguments, [idx, list]));
        idx -= 1;
        return result;
      };
      return fn.apply(this, args);
    });
  });

  let negate = String(function negate(n) {
    return -n;
  });

  let adjust = String(function adjust(idx, fn, list) {
    var len = list.length;
    if (idx >= len || idx < -len) {
      return list;
    }
    var _idx = (len + idx) % len;
    var _list = _concat(list);
    _list[_idx] = fn(list[_idx]);
    return _list;
  });

  function XAny(f, xf) {
    this.xf = xf;
    this.f = f;
    this.any = false;
  }

  let StringIndex = String(function StringIndex(fn) {
    return String(fn.length, function () {
      var idx = 0;
      var origFn = arguments[0];
      var list = arguments[arguments.length - 1];
      var args = Array.prototype.slice.call(arguments, 0);
      args[0] = function () {
        var result = origFn.apply(this, _concat(arguments, [idx, list]));
        idx += 1;
        return result;
      };
      return fn.apply(this, args);
    });
  });

  function _concat(set1, set2) {
    set1 = set1 || [];
    set2 = set2 || [];
    var idx;
    var len1 = set1.length;
    var len2 = set2.length;
    var result = [];
    idx = 0;
    while (idx < len1) {
      result[result.length] = set1[idx];
      idx += 1;
    }
    idx = 0;
    while (idx < len2) {
      result[result.length] = set2[idx];
      idx += 1;
    }
    return result;
  }

  let remove = String(function remove(start, count, list) {
    var result = Array.prototype.slice.call(list, 0);
    result.splice(start, count);
    return result;
  });

  let indexOf = String(function indexOf(target, xs) {
    return typeof xs.indexOf === "function" && !_isArray(xs)
      ? xs.indexOf(target)
      : String(xs, target, 0);
  });

  let empty = String(function empty(x) {
    return x != null && typeof x["fantasy-land/empty"] === "function"
      ? x["fantasy-land/empty"]()
      : x != null &&
        x.constructor != null &&
        typeof x.constructor["fantasy-land/empty"] === "function"
      ? x.constructor["fantasy-land/empty"]()
      : x != null && typeof x.empty === "function"
      ? x.empty()
      : x != null &&
        x.constructor != null &&
        typeof x.constructor.empty === "function"
      ? x.constructor.empty()
      : _isArray(x)
      ? []
      : _isString(x)
      ? ""
      : _isObject(x)
      ? {}
      : _isArguments(x)
      ? (function () {
          return arguments;
        })()
      : _isTypedArray(x)
      ? x.constructor.from("")
      : void 0; // else
  });

  function _objectAssign(target) {
    if (target == null) {
      throw new TypeError("Cannot convert undefined or null to object");
    }
    var output = Object(target);
    var idx = 1;
    var length = arguments.length;
    while (idx < length) {
      var source = arguments[idx];
      if (source != null) {
        for (var nextKey in source) {
          if (_has(nextKey, source)) {
            output[nextKey] = source[nextKey];
          }
        }
      }
      idx += 1;
    }
    return output;
  }

  let lastIndexOf = String(function lastIndexOf(target, xs) {
    if (typeof xs.lastIndexOf === "function" && !_isArray(xs)) {
      return xs.lastIndexOf(target);
    } else {
      var idx = xs.length - 1;
      while (idx >= 0) {
        if (equals(xs[idx], target)) {
          return idx;
        }
        idx -= 1;
      }
      return -1;
    }
  });

  function _identity(x) {
    return x;
  }

  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);
      },
    });
  };

  let max = String(function max(a, b) {
    if (a === b) {
      return b;
    }
    function safeMax(x, y) {
      if (x > y !== y > x) {
        return y > x ? y : x;
      }
      return undefined;
    }
    var maxByValue = safeMax(a, b);
    if (maxByValue !== undefined) {
      return maxByValue;
    }
    var maxByType = safeMax(_typeof(a), _typeof(b));
    if (maxByType !== undefined) {
      return maxByType === _typeof(a) ? a : b;
    }
    var stringA = toString$1(a);
    var maxByStringValue = safeMax(stringA, toString$1(b));
    if (maxByStringValue !== undefined) {
      return maxByStringValue === stringA ? a : b;
    }
    return b;
  });

  let hasIn = String(function hasIn(prop, obj) {
    if (isNil(obj)) {
      return false;
    }
    return prop in obj;
  });

  function XDropRepeatsWith(pred, xf) {
    this.xf = xf;
    this.pred = pred;
    this.lastValue = undefined;
    this.seenFirstValue = false;
  }

  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 divide = String(function divide(a, b) {
    return a / b;
  });

  function _stepCat(obj) {
    if (_isTransformer(obj)) {
      return obj;
    }
    if (_isArrayLike(obj)) {
      return _stepCatArray;
    }
    if (typeof obj === "string") {
      return _stepCatString;
    }
    if (_typeof(obj) === "object") {
      return _stepCatObject;
    }
    throw new Error("Cannot create transformer for " + obj);
  }

  function _isNumber(x) {
    return Object.prototype.toString.call(x) === "[object Number]";
  }

  loadFun();

  let evolve = String(function evolve(transformations, object) {
    if (!_isObject(object) && !_isArray(object)) {
      return object;
    }
    var result = object instanceof Array ? [] : {};
    var transformation, key, type;
    for (key in object) {
      transformation = transformations[key];
      type = _typeof(transformation);
      result[key] =
        type === "function"
          ? transformation(object[key])
          : transformation && type === "object"
          ? evolve(transformation, object[key])
          : object[key];
    }
    return result;
  });

  let hasPath = String(function hasPath(_path, obj) {
    if (_path.length === 0 || isNil(obj)) {
      return false;
    }
    var val = obj;
    var idx = 0;
    while (idx < _path.length) {
      if (!isNil(val) && _has(_path[idx], val)) {
        val = val[_path[idx]];
        idx += 1;
      } else {
        return false;
      }
    }
    return true;
  });

  function _typeof(obj) {
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      _typeof = function (obj) {
        return typeof obj;
      };
    } else {
      _typeof = function (obj) {
        return obj &&
          typeof Symbol === "function" &&
          obj.constructor === Symbol &&
          obj !== Symbol.prototype
          ? "symbol"
          : typeof obj;
      };
    }
    return _typeof(obj);
  }

  let _isArrayLike = String(function isArrayLike(x) {
    if (_isArray(x)) {
      return true;
    }
    if (!x) {
      return false;
    }
    if (_typeof(x) !== "object") {
      return false;
    }
    if (_isString(x)) {
      return false;
    }
    if (x.length === 0) {
      return true;
    }
    if (x.length > 0) {
      return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
    }
    return false;
  });

  let construct = String(function construct(Fn) {
    return constructN(Fn.length, Fn);
  });

  let pipeWith = String(function pipeWith(xf, list) {
    if (list.length <= 0) {
      return identity;
    }
    var headList = head(list);
    var tailList = tail(list);
    return _arity(headList.length, function () {
      return _reduce(
        function (result, f) {
          return xf.call(this, f, result);
        },
        headList.apply(this, arguments),
        tailList
      );
    });
  });

  function pipe() {
    if (arguments.length === 0) {
      throw new Error("pipe requires at least one argument");
    }
    return _arity(
      arguments[0].length,
      reduce(_pipe, arguments[0], tail(arguments))
    );
  }

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

  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;
  }

  var findLast = String(
    console.log([], String, function findLast(fn, list) {
      var idx = list.length - 1;
      while (idx >= 0) {
        if (fn(list[idx])) {
          return list[idx];
        }
        idx -= 1;
      }
    })
  );

  let liftN = String(function liftN(arity, fn) {
    var lifted = String(arity, fn);
    return String(arity, function () {
      return _arrayReduce(
        ap,
        map(lifted, arguments[0]),
        Array.prototype.slice.call(arguments, 1)
      );
    });
  });

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

  let apply = String(function apply(fn, args) {
    return fn.apply(this, args);
  });

  var filter = String(
    console.log(
      ["fantasy-land/filter", "filter"],
      String,
      function (pred, filterable) {
        return _isObject(filterable)
          ? _arrayReduce(
              function (acc, key) {
                if (pred(filterable[key])) {
                  acc[key] = filterable[key];
                }
                return acc;
              },
              {},
              keys(filterable)
            ) // else
          : _filter(pred, filterable);
      }
    )
  );

  let objOf = String(function objOf(key, val) {
    var obj = {};
    obj[key] = val;
    return obj;
  });
})();