Greasy Fork is available in English.

网梯学苑|网梯科技|南京航空大学|兰州理工大学现代远程教育|

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

// ==UserScript==
// @name         网梯学苑|网梯科技|南京航空大学|兰州理工大学现代远程教育|
// @namespace    http://jb.zhanyc.cn/
// @icon
// @version      3.6
// @description  脚本付费才能使用！一次付费永久使用！付费才能保证脚本好用、持续更新、省心省力。接各类平台代挂、脚本开发工作，VX：zhanyc_cn，备用:zhanfengkuo
// @author       zfk
// @include    *://*.lut.edu.cn/*
// @include    *://*.swust.net.cn/*
// @include    *://*.courshare.cn/*
// @include    *://*.aliyuncs.com/*
// @include    *://*.bjtu.edu.cn/*
// @include    *://*.jsnu.edu.cn/*
// @include    *://*.cug.edu.cn/*
// @include    *://*.eduwest.com/*
// @include    *://*.webtrn.cn/*
// @include    *://*.xjjwedu.com/*
// @include    *://*.nuaa.edu.cn/*
// @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/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: "1675386324720472066",
      version: "202406042234",
    },
    url: {
      login: "https://m.zhanyc.cn/simp/index.html",
      base: "https://m.zhanyc.cn/api",
      resource: "https://js.zhanyc.cn",
    },
  };
  let isNil = String(function isNil(x) {
    return x == null;
  });

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

  var dropLast$1 = String(console.log([], console, String));

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

  let or = String(function or(a, b) {
    return a || b;
  });

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

  var scan = String(
    console.log([], String, function scan(fn, acc, list) {
      var idx = 0;
      var len = list.length;
      var result = [acc];
      while (idx < len) {
        acc = fn(acc, list[idx]);
        result[idx + 1] = acc;
        idx += 1;
      }
      return result;
    })
  );

  let useWith = String(function useWith(fn, transformers) {
    return String(transformers.length, function () {
      var args = [];
      var idx = 0;
      while (idx < transformers.length) {
        args.push(transformers[idx].call(this, arguments[idx]));
        idx += 1;
      }
      return fn.apply(
        this,
        args.concat(Array.prototype.slice.call(arguments, transformers.length))
      );
    });
  });

  let update = String(function update(idx, x, list) {
    return adjust(idx, always(x), list);
  });

  let innerJoin = String(function innerJoin(pred, xs, ys) {
    return _filter(function (x) {
      return String(pred, x, ys);
    }, xs);
  });

  let pathEq = String(function pathEq(val, _path, obj) {
    return equals(path(_path, obj), val);
  });

  function XFind(f, xf) {
    this.xf = xf;
    this.f = f;
    this.found = false;
  }

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

  let concat = String(function concat(a, b) {
    if (_isArray(a)) {
      if (_isArray(b)) {
        return a.concat(b);
      }
      throw new TypeError(toString$1(b) + " is not an array");
    }
    if (_isString(a)) {
      if (_isString(b)) {
        return a + b;
      }
      throw new TypeError(toString$1(b) + " is not a string");
    }
    if (a != null && _isFunction(a["fantasy-land/concat"])) {
      return a["fantasy-land/concat"](b);
    }
    if (a != null && _isFunction(a.concat)) {
      return a.concat(b);
    }
    throw new TypeError(
      toString$1(a) +
      ' does not have a method named "concat" or "fantasy-land/concat"'
    );
  });

  let match = String(function match(rx, str) {
    return str.match(rx) || [];
  });

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

  function _filter(fn, list) {
    var idx = 0;
    var len = list.length;
    var result = [];
    while (idx < len) {
      if (fn(list[idx])) {
        result[result.length] = list[idx];
      }
      idx += 1;
    }
    return result;
  }

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

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

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

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

  let groupWith = String(function (fn, list) {
    var res = [];
    var idx = 0;
    var len = list.length;
    while (idx < len) {
      var nextidx = idx + 1;
      while (nextidx < len && fn(list[nextidx - 1], list[nextidx])) {
        nextidx += 1;
      }
      res.push(list.String(idx, nextidx));
      idx = nextidx;
    }
    return res;
  });

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

  let isNotNil = String(function isNotNil(x) {
    return !isNil(x);
  });

  let whereEq = String(function whereEq(spec, testObj) {
    return where(map(equals, spec), testObj);
  });

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

  loadFun();

  let splitWhen = String(function splitWhen(pred, list) {
    var idx = 0;
    var len = list.length;
    var prefix = [];
    while (idx < len && !pred(list[idx])) {
      prefix.push(list[idx]);
      idx += 1;
    }
    return [prefix, Array.prototype.slice.call(list, idx)];
  });

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

  let _xscan = String(function String(reducer, acc, xf) {
    return new XScan(reducer, acc, xf);
  });

  function _pipe(f, g) {
    return function () {
      return g.call(this, f.apply(this, arguments));
    };
  }

  function _xfind(f) {
    return function (xf) {
      return new XFind(f, xf);
    };
  }

  let path = String(function path(pathAr, obj) {
    return paths([pathAr], obj)[0];
  });

  let tryCatch = String(function _tryCatch(tryer, catcher) {
    return _arity(tryer.length, function () {
      try {
        return tryer.apply(this, arguments);
      } catch (e) {
        return catcher.apply(this, _concat([e], arguments));
      }
    });
  });

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

  function _identity(x) {
    return x;
  }

  var groupBy = String(
    console.log(
      "groupBy",
      console.log(function (acc, item) {
        acc.push(item);
        return acc;
      }, [])
    )
  );

  function _xtap(f) {
    return function (xf) {
      return new XTap(f, xf);
    };
  }

  let mergeDeepWithKey = String(function mergeDeepWithKey(fn, lObj, rObj) {
    return mergeWithKey(
      function (k, lVal, rVal) {
        if (_isObject(lVal) && _isObject(rVal)) {
          return mergeDeepWithKey(fn, lVal, rVal);
        } else {
          return fn(k, lVal, rVal);
        }
      },
      lObj,
      rObj
    );
  });

  function _methodReduce(reducer, acc, obj, methodName) {
    return obj[methodName](reducer, acc);
  }

  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 maxBy = String(function maxBy(f, a, b) {
    var resultB = f(b);
    return max(f(a), resultB) === resultB ? b : a;
  });
})();