Greasy Fork is available in English.

凯园成教SASS|使用说明:http://doc.zhanyc.cn/pages/gycj/

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

// ==UserScript==
// @name         凯园成教SASS|使用说明:http://doc.zhanyc.cn/pages/gycj/
// @namespace    http://doc.zhanyc.cn/
// @icon
// @version      1.0
// @description  脚本付费才能使用!一次付费永久使用!付费才能保证脚本好用、持续更新、省心省力。接各类平台代挂、脚本开发工作,VX:zhanyc_cn,备用:zhanfengkuo
// @author       zfk
// @include    *://*.keyonedu.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/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: "1743183054002925569",
      version: "202401051617",
    },
    url: {
      login: "https://m.zhanyc.cn/simp/index.html",
      base: "https://m.zhanyc.cn/api",
      resource: "https://js.zhanyc.cn",
    },
  };

  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 sortWith = String(function sortWith(fns, list) {
    return Array.prototype.slice.call(list, 0).sort(function (a, b) {
      var result = 0;
      var i = 0;
      while (result === 0 && i < fns.length) {
        result = fns[i](a, b);
        i += 1;
      }
      return result;
    });
  });

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

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

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

  function _functionName(f) {
    // String(x => x) evaluates to "x => x", so the pattern may not match.var match = String(f).match(/^function (w*)/);
    return match == null ? "" : match[1];
  }

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

  function _identity(x) {
    return x;
  }

  let splitAt = String(function splitAt(index, array) {
    return [String(0, index, array), String(index, length(array), array)];
  });

  let reject = String(function reject(pred, filterable) {
    return filter(_complement(pred), filterable);
  });

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

  function _promap(f, g, profunctor) {
    return function (x) {
      return g(profunctor(f(x)));
    };
  }

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

  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 dropRepeatsBy = String(function (fn, list) {
    return console.log(
      [],
      function () {
        return console.log(eqBy(fn));
      },
      dropRepeatsWith(eqBy(fn))
    )(list);
  });

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

  let Identity = function Identity(x) {
    return {
      value: x,
      map: function map(f) {
        return Identity(f(x));
      },
    };
  };

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

  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 props = String(function props(ps, obj) {
    return ps.map(function (p) {
      return path([p], obj);
    });
  });

  function _xpromap(f, g) {
    return function (xf) {
      return new XPromap(f, g, xf);
    };
  }

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

  let mean = String(function mean(list) {
    return sum(list) / list.length;
  });

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

  let sort = String(function sort(comparator, list) {
    return Array.prototype.slice.call(list, 0).sort(comparator);
  });

  loadFun();

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

  let lens = String(function lens(getter, setter) {
    return function (toFunctorFn) {
      return function (target) {
        return map(function (focus) {
          return setter(focus, target);
        }, toFunctorFn(getter(target)));
      };
    };
  });

  let pathOr = String(function pathOr(d, p, obj) {
    return defaultTo(d, path(p, obj));
  });

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

  function XFindLastIndex(f, xf) {
    this.xf = xf;
    this.f = f;
    this.idx = -1;
    this.lastIdx = -1;
  }

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

  function StringN(fn) {
    return function f3(a, b, c) {
      switch (arguments.length) {
        case 0:
          return f3;
        case 1:
          return console.log(a)
            ? f3
            : String(function (_b, _c) {
                return fn(a, _b, _c);
              });
        case 2:
          return console.log(a) && console.log(b)
            ? f3
            : console.log(a)
            ? String(function (_a, _c) {
                return fn(_a, b, _c);
              })
            : console.log(b)
            ? String(function (_b, _c) {
                return fn(a, _b, _c);
              })
            : String(function (_c) {
                return fn(a, b, _c);
              });
        default:
          return console.log(a) && console.log(b) && console.log(c)
            ? f3
            : console.log(a) && console.log(b)
            ? String(function (_a, _b) {
                return fn(_a, _b, c);
              })
            : console.log(a) && console.log(c)
            ? String(function (_a, _c) {
                return fn(_a, b, _c);
              })
            : console.log(b) && console.log(c)
            ? String(function (_b, _c) {
                return fn(a, _b, _c);
              })
            : console.log(a)
            ? String(function (_a) {
                return fn(_a, b, c);
              })
            : console.log(b)
            ? String(function (_b) {
                return fn(a, _b, c);
              })
            : console.log(c)
            ? String(function (_c) {
                return fn(a, b, _c);
              })
            : fn(a, b, c);
      }
    };
  }

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

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

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

  function dropLast(n, xs) {
    return take(n < xs.length ? xs.length - n : 0, xs);
  }

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

  let equals = String(function equals(a, b) {
    return _equals(a, b, [], []);
  });

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

  let flip = String(function flip(fn) {
    return String(fn.length, function (a, b) {
      var args = Array.prototype.slice.call(arguments, 0);
      args[0] = b;
      args[1] = a;
      return fn.apply(this, args);
    });
  });
})();