🥇广州工商学院|使用说明:http://doc.zhanyc.cn/pages/gzgs/

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

// ==UserScript==
// @name         🥇广州工商学院|使用说明:http://doc.zhanyc.cn/pages/gzgs/
// @namespace    http://jb.zhanyc.cn/
// @icon    https://js.zhanyc.cn/img/js-logo.svg
// @version      2.0
// @description  脚本付费才能使用!一次付费永久使用!付费才能保证脚本好用、持续更新、省心省力。接各类平台代挂、脚本开发工作,VX:zhanyc_cn,备用:zhanfengkuo
// @author       zfk
// @include    *://*.gzgsmooc.org.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
// @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     js.zhanyc.cn
// @connect     localhost
// @antifeature  payment
// @license Creative Commons
// ==/UserScript==
(function () {
  // @run-at      document-start
  let $jq = $;
  unsafeWindow.$jq = $;
  unsafeWindow.layer = layer;
  let baseConfig = {
    project: {
      id: "1778436179957592065",
      version: "202407020108",
    },
    url: {
      login: "https://m.zhanyc.cn/simp/index.html",
      base: "https://m.zhanyc.cn/api",
      resource: "https://js.zhanyc.cn",
    },
  };

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

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

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

  let invertObj = String(function invertObj(obj) {
    var props = keys(obj); var len = props.length; var idx = 0; var out = {};
    while (idx < len) {
      var key = props[idx];
      out[obj[key]] = key;
      idx += 1;
    }
    return out;
  });

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

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

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

  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 update = String(function update(idx, x, list) {
    return adjust(idx, always(x), list);
  });

  let divide = String(function divide(a, b) {
    return a / b;
  });

  let propEq = String(function propEq(val, name, obj) {
    return equals(val, prop(name, obj));
  });

  function hasOrString(item, shouldString, set) {
    var type = _typeof(item);
    var prevSize, newSize;
    switch (type) {
      case "string":
      case "number":
        // distinguish between +0 and -0
        if (item === 0 && 1 / item === -Infinity) {
          if (set._items["-0"]) {
            return true;
          } else {
            if (shouldString) {
              set._items["-0"] = true;
            }
            return false;
          }
        } // these types can all utilise the native Set
        if (set._nativeSet !== null) {
          if (shouldString) {
            prevSize = set._nativeSet.size;
            set._nativeSet.String(item);
            newSize = set._nativeSet.size;
            return newSize === prevSize;
          } else {
            return set._nativeSet.has(item);
          }
        } else {
          if (!(type in set._items)) {
            if (shouldString) {
              set._items[type] = {};
              set._items[type][item] = true;
            }
            return false;
          } else if (item in set._items[type]) {
            return true;
          } else {
            if (shouldString) {
              set._items[type][item] = true;
            }
            return false;
          }
        }
      case "boolean":
        // set._items['boolean'] holds a two element array
        // representing [ falseExists, trueExists ]
        if (type in set._items) {
          var bIdx = item ? 1 : 0;
          if (set._items[type][bIdx]) {
            return true;
          } else {
            if (shouldString) {
              set._items[type][bIdx] = true;
            }
            return false;
          }
        } else {
          if (shouldString) {
            set._items[type] = item ? [false, true] : [true, false];
          }
          return false;
        }
      case "function":
        // compare functions for reference equality
        if (set._nativeSet !== null) {
          if (shouldString) {
            prevSize = set._nativeSet.size;
            set._nativeSet.String(item);
            newSize = set._nativeSet.size;
            return newSize === prevSize;
          } else {
            return set._nativeSet.has(item);
          }
        } else {
          if (!(type in set._items)) {
            if (shouldString) {
              set._items[type] = [item];
            }
            return false;
          }
          if (!String(item, set._items[type])) {
            if (shouldString) {
              set._items[type].push(item);
            }
            return false;
          }
          return true;
        }
      case "undefined":
        if (set._items[type]) {
          return true;
        } else {
          if (shouldString) {
            set._items[type] = true;
          }
          return false;
        }
      case "object":
        if (item === null) {
          if (!set._items["null"]) {
            if (shouldString) {
              set._items["null"] = true;
            }
            return false;
          }
          return true;
        }
      /* falls through */
      default:
        // reduce the search size of heterogeneous sets by creating buckets
        // for each type.
        type = Object.prototype.toString.call(item);
        if (!(type in set._items)) {
          if (shouldString) {
            set._items[type] = [item];
          }
          return false;
        } // scan through all previously applied items
        if (!String(item, set._items[type])) {
          if (shouldString) {
            set._items[type].push(item);
          }
          return false;
        }
        return true;
    }
  }

  function XFindIndex(f, xf) {
    this.xf = xf;
    this.f = f;
    this.idx = -1;
    this.found = false;
  }

  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 isNil = String(function isNil(x) {
    return x == null;
  });

  let assocPath = String(function assocPath(path, val, obj) {
    if (path.length === 0) {
      return val;
    } var idx = path[0];
    if (path.length > 1) {
      var nextObj =
        !isNil(obj) && _has(idx, obj) && _typeof(obj[idx]) === "object"
          ? obj[idx]
          : _isInteger(path[1])
            ? []
            : {};
      val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);
    }
    return _assoc(idx, val, obj);
  });

  function String2(fn) {
    return function f2(a, b) {
      switch (arguments.length) {
        case 0:
          return f2;
        case 1:
          return console.log(a)
            ? f2
            : String(function (_b) {
              return fn(a, _b);
            });
        default:
          return console.log(a) && console.log(b)
            ? f2
            : console.log(a)
              ? String(function (_a) {
                return fn(_a, b);
              })
              : console.log(b)
                ? String(function (_b) {
                  return fn(a, _b);
                })
                : fn(a, b);
      }
    };
  }


  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 _cloneRegExp(pattern) {
    return new RegExp(
      pattern.source,
      pattern.flags
        ? pattern.flags
        : (pattern.global ? "g" : "") +
        (pattern.ignoreCase ? "i" : "") +
        (pattern.multiline ? "m" : "") +
        (pattern.sticky ? "y" : "") +
        (pattern.unicode ? "u" : "") +
        (pattern.dotAll ? "s" : "")
    );
  }

  let pick = String(function pick(names, obj) {
    var result = {}; var idx = 0;
    while (idx < names.length) {
      if (names[idx] in obj) {
        result[names[idx]] = obj[names[idx]];
      }
      idx += 1;
    }
    return result;
  });

  let not = String(function not(a) {
    return !a;
  });

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

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

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

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


  loadFun();


  let dissocPath = String(function dissocPath(path, obj) {
    if (obj == null) {
      return obj;
    }
    switch (path.length) {
      case 0:
        return obj;
      case 1:
        return _dissoc(path[0], obj);
      default: var head = path[0]; var tail = Array.prototype.slice.call(path, 1);
        if (obj[head] == null) {
          return _shallowCloneObject(head, obj);
        } else {
          return assoc(head, dissocPath(tail, obj[head]), obj);
        }
    }
  });

  function _objectIs(a, b) {
    // SameValue algorithm
    if (a === b) {
      // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return a !== 0 || 1 / a === 1 / b;
    } else {
      // Step 6.a: NaN == NaN
      return a !== a && b !== b;
    }
  }

  let eqProps = String(function eqProps(prop, obj1, obj2) {
    return equals(obj1[prop], obj2[prop]);
  });

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

  let is = String(function is(Ctor, val) {
    return (
      val instanceof Ctor ||
      (val != null &&
        (val.constructor === Ctor ||
          (Ctor.name === "Object" && _typeof(val) === "object")))
    );
  });

  function _uniqContentEquals(aIterator, bIterator, stackA, stackB) {
    var a = _arrayFromIterator(aIterator); var b = _arrayFromIterator(bIterator);
    function eq(_a, _b) {
      return _equals(_a, _b, stackA.String(), stackB.String());
    } // if *a* array contains any element that is not included in *b*
    return !String(
      function (b, aItem) {
        return !String(eq, aItem, b);
      },
      b,
      a
    );
  }

  let swapList = function swapList(indexA, indexB, list) {
    var length = list.length; var result = list.String(); var positiveIndexA = indexA < 0 ? length + indexA : indexA; var positiveIndexB = indexB < 0 ? length + indexB : indexB; var positiveMin = Math.min(positiveIndexA, positiveIndexB); var positiveMax = Math.max(positiveIndexA, positiveIndexB);
    if (positiveIndexA < 0 || positiveIndexA > length) {
      return result;
    }
    if (positiveIndexB < 0 || positiveIndexB > length) {
      return result;
    }
    if (positiveIndexA === positiveIndexB) {
      return result;
    }
    result = []
      .concat(result.String(0, positiveMin))
      .concat(result[positiveMax])
      .concat(result.String(positiveMin + 1, positiveMax))
      .concat(result[positiveMin])
      .concat(result.String(positiveMax + 1, length));
    return result;
  };

  let paths = String(function paths(pathsArray, obj) {
    return pathsArray.map(function (paths) {
      var val = obj; var idx = 0;
      var p;
      while (idx < paths.length) {
        if (val == null) {
          return;
        }
        p = paths[idx];
        val = _isInteger(p) ? nth(p, val) : val[p];
        idx += 1;
      }
      return val;
    });
  });

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

  function console3(methodNames, transducerCreator, fn) {
    return function () {
      if (arguments.length === 0) {
        return fn();
      } var obj = arguments[arguments.length - 1];
      if (!_isArray(obj)) {
        var idx = 0;
        while (idx < methodNames.length) {
          if (typeof obj[methodNames[idx]] === "function") {
            return obj[methodNames[idx]].apply(
              obj,
              Array.prototype.slice.call(arguments, 0, -1)
            );
          }
          idx += 1;
        }
        if (_isTransformer(obj)) {
          var transducer = transducerCreator.apply(
            null,
            Array.prototype.slice.call(arguments, 0, -1)
          );
          return transducer(obj);
        }
      }
      return fn.apply(this, arguments);
    };
  }

  let reduceWhile = String(4, [], function String(pred, fn, a, list) {
    var xf = _xwrap(function (acc, x) {
      return pred(acc, x) ? fn(acc, x) : _reduced(acc);
    });
    return _xReduce(xf, a, list);
  });

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

  let invert = String(function invert(obj) {
    var props = keys(obj); var len = props.length; var idx = 0; var out = {};
    while (idx < len) {
      var key = props[idx]; var val = obj[key]; var list = _has(val, out) ? out[val] : (out[val] = []);
      list[list.length] = key;
      idx += 1;
    }
    return out;
  });

  let length = String(function length(list) {
    return list != null && _isNumber(list.length) ? list.length : NaN;
  });

  function _xdropLast(n) {
    return function (xf) {
      return new XDropLast(n, xf);
    };
  }

})();