Function 7c73 has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

/***/ (function(module, exports, __webpack_require__) {

var anObject = __webpack_require__("825a");
var defineProperties = __webpack_require__("37e8");
var enumBugKeys = __webpack_require__("7839");

Function exports has 54 lines of code (exceeds 25 allowed). Consider refactoring.

Open

module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
  createIteratorConstructor(IteratorConstructor, NAME, next);

  var getIterationMethod = function (KIND) {
    if (KIND === DEFAULT && defaultIterator) return defaultIterator;

Function mountElement has 53 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
            let el;
            let vnodeHook;
            const { type, props, shapeFlag, transition, patchFlag, dirs } = vnode;
            {

Function genNode has 53 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function genNode(node, context) {
    if (isString(node)) {
            context.push(node);
            return;
    }

Function resolveComponentType has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

function resolveComponentType(node, context, ssr = false) {
    let { tag } = node;
    // 1. dynamic component
    const isExplicitDynamic = isComponentTag(tag);
    const isProp = findProp(node, 'is') || (!isExplicitDynamic && findDir(node, 'is'));

• Read up
  Read up

Function transformOn$1 has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

const transformOn$1 = (dir, node, context) => {
    return transformOn(dir, node, context, baseResult => {
            const { modifiers } = dir;
            if (!modifiers.length)
                    return baseResult;

• Read up
  Read up

Function useHistoryListeners has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

function useHistoryListeners(base, historyState, currentLocation, replace) {
    let listeners = [];
    let teardowns = [];
    // TODO: should it be a stack? a Dict. Check if the popstate listener
    // can trigger twice

• Read up
  Read up

Function formatComponentName has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

function formatComponentName(instance, Component, isRoot = false) {
    let name = getComponentName(Component);
    if (!name && Component.__file) {
            const match = Component.__file.match(/([^/\\]+)\.\w+$/);
            if (match) {

• Read up
  Read up

Function parseQuery has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

function parseQuery(search) {
    const query = {};
    // avoid creating an object with an empty key and empty value
    // because of split('&')
    if (search === "" || search === "?") return query;

• Read up
  Read up

Function exports has 52 lines of code (exceeds 25 allowed). Consider refactoring.

Open

module.exports = function (KEY, length, exec, sham) {
  var SYMBOL = wellKnownSymbol(KEY);

  var DELEGATES_TO_SYMBOL = !fails(function () {
    // String methods call symbol-named RegEp methods

Function resolve has 51 lines of code (exceeds 25 allowed). Consider refactoring.

Open

            resolve(resume = false) {
                    {
                            if (!resume && !suspense.pendingBranch) {
                                    throw new Error(`suspense.resolve() is called without a pending branch.`);
                            }

Function parseForExpression has 50 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function parseForExpression(input, context) {
    const loc = input.loc;
    const exp = input.content;
    const inMatch = exp.match(forAliasRE);
    if (!inMatch)

Function transformText has 50 lines of code (exceeds 25 allowed). Consider refactoring.

Open

const transformText = (node, context) => {
    if (node.type === 0 /* ROOT */ ||
            node.type === 1 /* ELEMENT */ ||
            node.type === 11 /* FOR */ ||
            node.type === 10 /* IF_BRANCH */) {

Function setup has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    setup(props, { slots }) {
        const link = reactive(useLink(props));
        const { options } = inject(routerKey);
        const elClass = computed(() => ({
            [getLinkClass(

Function setupListeners has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function setupListeners() {
        removeHistoryListener = routerHistory.listen((to, _from, info) => {
            // cannot be a redirect route because it was in history
            let toLocation = resolve(to);
            // due to dynamic routing, and to hash history with manual navigation

Function renderRangeList has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    renderRangeList: function renderRangeList(rawRange, section) {
      var _this10 = this;

      if (!rawRange || !section || !this.isMinuteOrSecond(section)) {
        return [];

Function _createForOfIteratorHelper has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function _createForOfIteratorHelper(o, allowArrayLike) {
  var it;

  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {

Function move has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
            const { el, type, transition, children, shapeFlag } = vnode;
            if (shapeFlag & 6 /* COMPONENT */) {
                    move(vnode.component.subTree, container, anchor, moveType);
                    return;

Function cloneVNode has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

function cloneVNode(vnode, extraProps, mergeRef = false) {
    // This is intentionally NOT using spread or extend to avoid the runtime
    // key enumeration cost.
    const { props, ref, patchFlag, children } = vnode;
    const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;

• Read up
  Read up

Function createRootCodegen has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

function createRootCodegen(root, context) {
    const { helper, removeHelper } = context;
    const { children } = root;
    if (children.length === 1) {
            const child = children[0];

• Read up
  Read up