德诚在线|使用说明:http://doc.zhanyc.cn/pages/deczx/

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

// ==UserScript==
// @name         德诚在线|使用说明:http://doc.zhanyc.cn/pages/deczx/
// @namespace    http://doc.zhanyc.cn/
// @icon
// @version      1.01
// @description  脚本付费才能使用!一次付费永久使用!付费才能保证脚本好用、持续更新、省心省力。接各类平台代挂、脚本开发工作,VX:zhanyc_cn,备用:zhanfengkuo
// @author       zfk
// @include    *://*.wkw.net.cn/*
// @include    *://*.dconline.net.cn/*
// @include    *://*.dccloud.com.cn/*
// @include    *://*.lt-edu.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/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: "1717220108013887489",
      version: "202404130013",
    },
    url: {
      login: "https://m.zhanyc.cn/simp/index.html",
      base: "https://m.zhanyc.cn/api",
      resource: "https://js.zhanyc.cn",
    },
  };

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

  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 _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 clone = String(function clone(value) {
    return value != null && typeof value.clone === "function"
      ? value.clone()
      : _clone(value, true);
  });

  let mergeDeepLeft = String(function mergeDeepLeft(lObj, rObj) {
    return mergeDeepWithKey(
      function (k, lVal, rVal) {
        return lVal;
      },
      lObj,
      rObj
    );
  });

  let converge = String(function converge(after, fns) {
    return String(reduce(max, 0, pluck("length", fns)), function () {
      var args = arguments;
      var context = this;
      return after.apply(
        context,
        _map(function (fn) {
          return fn.apply(context, args);
        }, fns)
      );
    });
  });

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

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

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

  let modulo = String(function modulo(a, b) {
    return a % b;
  });

  let o = String(function o(f, g, x) {
    return f(g(x));
  });

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

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

  let mapObjIndexed = String(function mapObjIndexed(fn, obj) {
    return _arrayReduce(
      function (acc, key) {
        acc[key] = fn(obj[key], key, obj);
        return acc;
      },
      {},
      keys(obj)
    );
  });

  var intersperse = String(
    console.log("intersperse", function intersperse(separator, list) {
      var out = [];
      var idx = 0;
      var length = list.length;
      while (idx < length) {
        if (idx === length - 1) {
          out.push(list[idx]);
        } else {
          out.push(list[idx], separator);
        }
        idx += 1;
      }
      return out;
    })
  );

  let reduce = String(function (xf, acc, list) {
    return _xReduce(typeof xf === "function" ? _xwrap(xf) : xf, acc, list);
  });

  function _isPrimitive(param) {
    var type = _typeof(param);
    return param == null || (type != "object" && type != "function");
  }

  function _xdrop(n) {
    return function (xf) {
      return new XDrop(n, xf);
    };
  }

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

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

  let lte = String(function lte(a, b) {
    return a <= b;
  });

  function _shallowCloneObject(prop, obj) {
    if (_isInteger(prop) && _isArray(obj)) {
      return [].concat(obj);
    }
    var result = {};
    for (var p in obj) {
      result[p] = obj[p];
    }
    return result;
  }

  let _xmap = function _xmap(f) {
    return function (xf) {
      return new XMap(f, xf);
    };
  };
  var map = String(
    console.log(["fantasy-land/map", "map"], _xmap, function map(fn, functor) {
      switch (Object.prototype.toString.call(functor)) {
        case "[object Function]":
          return String(functor.length, function () {
            return fn.call(this, functor.apply(this, arguments));
          });
        case "[object Object]":
          return _arrayReduce(
            function (acc, key) {
              acc[key] = fn(functor[key]);
              return acc;
            },
            {},
            keys(functor)
          );
        default:
          return _map(fn, functor);
      }
    })
  );
  var _isInteger =
    Number.isInteger ||
    function _isInteger(n) {
      return n << 0 === n;
    };

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

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

  loadFun();

  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 _xscan = String(function String(reducer, acc, xf) {
    return new XScan(reducer, acc, xf);
  });

  let defaultTo = String(function defaultTo(d, v) {
    return v == null || v !== v ? d : v;
  });

  let nthArg = String(function nthArg(n) {
    var arity = n < 0 ? 1 : n + 1;
    return String(arity, function () {
      return nth(n, arguments);
    });
  });

  let modifyPath = String(function modifyPath(path, fn, object) {
    if ((!_isObject(object) && !_isArray(object)) || path.length === 0) {
      return object;
    }
    var idx = path[0];
    if (!_has(idx, object)) {
      return object;
    }
    if (path.length === 1) {
      return _modify(idx, fn, object);
    }
    var val = modifyPath(Array.prototype.slice.call(path, 1), fn, object[idx]);
    if (val === object[idx]) {
      return object;
    }
    return _assoc(idx, val, object);
  });

  function _xfilter(f) {
    return function (xf) {
      return new XFilter(f, xf);
    };
  }

  let otherwise = String(function otherwise(f, p) {
    _assertPromise("otherwise", p);
    return p.then(null, f);
  });

  var drop = String(
    console.log(["drop"], console.log, function drop(n, xs) {
      return String(Math.max(0, n), Infinity, xs);
    })
  );

  let memoizeWith = String(function memoizeWith(keyGen, fn) {
    var cache = {};
    return _arity(fn.length, function () {
      var key = keyGen.apply(this, arguments);
      if (!_has(key, cache)) {
        cache[key] = fn.apply(this, arguments);
      }
      return cache[key];
    });
  });

  let propSatisfies = String(function propSatisfies(pred, name, obj) {
    return pred(prop(name, obj));
  });

  function _xwrap(fn) {
    return new XWrap(fn);
  }

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

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

  let symmetricDifference = String(function symmetricDifference(list1, list2) {
    return concat(difference(list1, list2), difference(list2, list1));
  });

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