Sign upLogin

WordPress/WordPress

View on GitHub
Star
wp-includes/js/mediaelement/mediaelement-and-player.js

Summary

Maintainability
F
1 yr
Test Coverage

Function 5 has a Cognitive Complexity of 1230 (exceeds 5 allowed). Consider refactoring.
Open

},{}],5:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
Severity: Minor
Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 wks to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

File mediaelement-and-player.js has 7013 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * MediaElement.js
 * http://www.mediaelementjs.com/
 *
 * Wrapper that mimics native HTML5 MediaElement (audio and video)
Severity: Major
Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 wks to fix

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

    },{}],16:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
    Severity: Minor
    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 wks to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function 16 has 1513 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    },{}],16:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
    Severity: Major
    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 wk to fix

      Function MediaElementPlayer has 1420 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      var MediaElementPlayer = function () {
    function MediaElementPlayer(node, o) {
        _classCallCheck(this, MediaElementPlayer);

        var t = this,
      Severity: Major
      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 wk to fix

        Function 13 has a Cognitive Complexity of 258 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"16":16,"2":2,"26":26,"30":30}],13:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
        Severity: Minor
        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 days to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function 6 has a Cognitive Complexity of 215 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"15":15,"27":27,"7":7}],6:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
        Severity: Minor
        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 days to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function 11 has a Cognitive Complexity of 186 (exceeds 5 allowed). Consider refactoring.
        Open

        },{"16":16,"2":2,"26":26,"27":27,"5":5}],11:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
        Severity: Minor
        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 days to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function 13 has 650 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        },{"16":16,"2":2,"26":26,"30":30}],13:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
        Severity: Major
        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 days to fix

          Function 30 has a Cognitive Complexity of 135 (exceeds 5 allowed). Consider refactoring.
          Open

          },{"2":2,"4":4}],30:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
          Severity: Minor
          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 days to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function 9 has a Cognitive Complexity of 121 (exceeds 5 allowed). Consider refactoring.
          Open

          },{"7":7}],9:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
          Severity: Minor
          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 days to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function 11 has 488 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          },{"16":16,"2":2,"26":26,"27":27,"5":5}],11:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
          Severity: Major
          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 days to fix

            Function 24 has a Cognitive Complexity of 118 (exceeds 5 allowed). Consider refactoring.
            Open

            },{"2":2,"25":25,"27":27,"3":3,"7":7,"8":8}],24:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
            Severity: Minor
            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 days to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function 24 has 450 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            },{"2":2,"25":25,"27":27,"3":3,"7":7,"8":8}],24:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
            Severity: Major
            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 days to fix

              Function 20 has a Cognitive Complexity of 107 (exceeds 5 allowed). Consider refactoring.
              Open

              },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],20:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
              Severity: Minor
              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 days to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function buildprogress has 411 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  buildprogress: function buildprogress(player, controls, layers, media) {

        var lastKeyPressTime = 0,
            mouseIsDown = false,
            startedPaused = false;
              Severity: Major
              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 days to fix

                Function 6 has 366 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                },{"15":15,"27":27,"7":7}],6:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                Severity: Major
                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                  Function 20 has 347 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],20:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                  Severity: Major
                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                    Function MediaElement has 345 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    var MediaElement = function MediaElement(idOrNode, options, sources) {
    var _this = this;

    _classCallCheck(this, MediaElement);
                    Severity: Major
                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                      Function 26 has a Cognitive Complexity of 84 (exceeds 5 allowed). Consider refactoring.
                      Open

                      },{"2":2,"3":3,"7":7}],26:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                      Severity: Minor
                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function 14 has a Cognitive Complexity of 83 (exceeds 5 allowed). Consider refactoring.
                      Open

                      },{"16":16,"2":2,"26":26,"27":27,"30":30,"5":5,"7":7}],14:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                      Severity: Minor
                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function create has 328 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          create: function create(mediaElement, options, mediaFiles) {

        var youtube = {},
            apiStack = [],
            readyState = 4;
                      Severity: Major
                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                        Function 14 has 316 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        },{"16":16,"2":2,"26":26,"27":27,"30":30,"5":5,"7":7}],14:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                        Severity: Major
                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                          Function buildvolume has 293 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              buildvolume: function buildvolume(player, controls, layers, media) {
        if ((_constants.IS_ANDROID || _constants.IS_IOS) && this.options.hideVolumeOnTouchDevices) {
            return;
        }
                          Severity: Major
                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                            Function 8 has a Cognitive Complexity of 68 (exceeds 5 allowed). Consider refactoring.
                            Open

                            },{"3":3}],8:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                            Severity: Minor
                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function 4 has a Cognitive Complexity of 63 (exceeds 5 allowed). Consider refactoring.
                            Open

                            },{}],4:[function(_dereq_,module,exports){
(function (root) {

  // Store setTimeout reference so promise-polyfill will be unaffected by
  // other code modifying setTimeout (like sinon.useFakeTimers())
                            Severity: Minor
                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function 22 has 236 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],22:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                            Severity: Major
                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                              Function 9 has 233 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              },{"7":7}],9:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
                              Severity: Major
                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                                Function _meReady has 233 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                        value: function _meReady(media, domNode) {
            var t = this,
                autoplayAttr = domNode.getAttribute('autoplay'),
                autoplay = !(autoplayAttr === undefined || autoplayAttr === null || autoplayAttr === 'false'),
                isNative = media.rendererName !== null && /(native|html5)/i.test(media.rendererName);
                                Severity: Major
                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                                  Function 5 has 231 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  },{}],5:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                  Severity: Major
                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                                    Function 30 has 202 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                    },{"2":2,"4":4}],30:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                    Severity: Major
                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 day to fix

                                      Function 21 has 196 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                      },{"2":2,"25":25,"27":27,"28":28,"3":3,"5":5,"7":7,"8":8}],21:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                      Severity: Major
                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                        Function 19 has 195 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                        },{"16":16,"3":3,"7":7}],19:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                        Severity: Major
                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                          Function 26 has 194 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                          },{"2":2,"3":3,"7":7}],26:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                          Severity: Major
                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                            Function t has 193 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                            i18n.t = function (message) {
    var pluralParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;


    if (typeof message === 'string' && message.length) {
                                            Severity: Major
                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                              Function create has 193 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                  create: function create(mediaElement, options, mediaFiles) {

        var flash = {};
        var isActive = false;
                                              Severity: Major
                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                                Function 29 has a Cognitive Complexity of 48 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                },{"27":27,"7":7}],29:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                                                Severity: Minor
                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                                Cognitive Complexity

                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                A method's cognitive complexity is based on a few simple rules:

                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                • Code is considered more complex when "flow breaking structures are nested"

                                                Further reading

                                                Function 4 has 183 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                },{}],4:[function(_dereq_,module,exports){
(function (root) {

  // Store setTimeout reference so promise-polyfill will be unaffected by
  // other code modifying setTimeout (like sinon.useFakeTimers())
                                                Severity: Major
                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                                  Function create has 181 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                      create: function create(mediaElement, options, mediaFiles) {

        var originalNode = mediaElement.originalNode,
            id = mediaElement.id + '_' + options.prefix,
            preload = originalNode.getAttribute('preload'),
                                                  Severity: Major
                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 7 hrs to fix

                                                    Function _plural has 165 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                            var _plural = function _plural(input, number, form) {

            if ((typeof input === 'undefined' ? 'undefined' : _typeof(input)) !== 'object' || typeof number !== 'number' || typeof form !== 'number') {
                return input;
            }
                                                    Severity: Major
                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 6 hrs to fix

                                                      Function 17 has 161 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                      },{"17":17,"2":2,"25":25,"26":26,"27":27,"28":28,"3":3,"30":30,"5":5,"6":6,"7":7}],17:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                      Severity: Major
                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 6 hrs to fix

                                                        Function _pluralForms has 159 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                                    var _pluralForms = function () {
                return [function () {
                    return arguments.length <= 1 ? undefined : arguments[1];
                }, function () {
                    return (arguments.length <= 0 ? undefined : arguments[0]) === 1 ? arguments.length <= 1 ? undefined : arguments[1] : arguments.length <= 2 ? undefined : arguments[2];
                                                        Severity: Major
                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 6 hrs to fix

                                                          Function 25 has 154 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                          },{"2":2,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],25:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                          Severity: Major
                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 6 hrs to fix

                                                            Function DefaultPlayer has 149 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                            var DefaultPlayer = function () {
    function DefaultPlayer(player) {
        _classCallCheck(this, DefaultPlayer);

        this.media = player.media;
                                                            Severity: Major
                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                              Function create has 139 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

                                                                  create: function create(mediaElement, options, mediaFiles) {

        var originalNode = mediaElement.originalNode,
            id = mediaElement.id + '_' + options.prefix;
                                                              Severity: Major
                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                                Function create has 139 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                Open

                                                                    create: function create(mediaElement, options, mediaFiles) {

        var originalNode = mediaElement.originalNode,
            id = mediaElement.id + '_' + options.prefix,
            autoplay = originalNode.autoplay,
                                                                Severity: Major
                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                                  Function 28 has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
                                                                  Open

                                                                  },{"7":7}],28:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                  Severity: Minor
                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                                  Cognitive Complexity

                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                  Further reading

                                                                  Function 19 has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
                                                                  Open

                                                                  },{"16":16,"3":3,"7":7}],19:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                                                  Severity: Minor
                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                                  Cognitive Complexity

                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                  Further reading

                                                                  Function buildtracks has 131 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                      buildtracks: function buildtracks(player, controls, layers, media) {

        this.findTracks();

        if (!player.tracks.length && (!player.trackFiles || !player.trackFiles.length === 0)) {
                                                                  Severity: Major
                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                                    Function 25 has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.
                                                                    Open

                                                                    },{"2":2,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],25:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                    Severity: Minor
                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                                    Cognitive Complexity

                                                                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                    A method's cognitive complexity is based on a few simple rules:

                                                                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                    • Code is considered more complex for each "break in the linear flow of the code"
                                                                    • Code is considered more complex when "flow breaking structures are nested"

                                                                    Further reading

                                                                    Function 29 has 126 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                    Open

                                                                    },{"27":27,"7":7}],29:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                                                                    Severity: Major
                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 5 hrs to fix

                                                                      Function 12 has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring.
                                                                      Open

                                                                      },{"16":16,"2":2,"25":25,"26":26,"30":30,"5":5}],12:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                                                                      Severity: Minor
                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                      Cognitive Complexity

                                                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                      A method's cognitive complexity is based on a few simple rules:

                                                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                      • Code is considered more complex for each "break in the linear flow of the code"
                                                                      • Code is considered more complex when "flow breaking structures are nested"

                                                                      Further reading

                                                                      Function 22 has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring.
                                                                      Open

                                                                      },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],22:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                                                      Severity: Minor
                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                      Cognitive Complexity

                                                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                      A method's cognitive complexity is based on a few simple rules:

                                                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                      • Code is considered more complex for each "break in the linear flow of the code"
                                                                      • Code is considered more complex when "flow breaking structures are nested"

                                                                      Further reading

                                                                      Function 21 has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.
                                                                      Open

                                                                      },{"2":2,"25":25,"27":27,"28":28,"3":3,"5":5,"7":7,"8":8}],21:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                                                      Severity: Minor
                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                      Cognitive Complexity

                                                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                      A method's cognitive complexity is based on a few simple rules:

                                                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                      • Code is considered more complex for each "break in the linear flow of the code"
                                                                      • Code is considered more complex when "flow breaking structures are nested"

                                                                      Further reading

                                                                      Function buildoverlays has 109 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                      Open

                                                                              value: function buildoverlays(player, controls, layers, media) {

            if (!player.isVideo) {
                return;
            }
                                                                      Severity: Major
                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                        Function 23 has 108 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                        },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],23:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
                                                                        Severity: Major
                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                          Function 23 has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
                                                                          Open

                                                                          },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],23:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
                                                                          Severity: Minor
                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                          Cognitive Complexity

                                                                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                          A method's cognitive complexity is based on a few simple rules:

                                                                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                          • Code is considered more complex for each "break in the linear flow of the code"
                                                                          • Code is considered more complex when "flow breaking structures are nested"

                                                                          Further reading

                                                                          Function 27 has 104 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                          },{"2":2,"3":3,"7":7}],27:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                          Severity: Major
                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                            Function init has 103 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                            Open

                                                                                    value: function init() {
            var t = this,
                playerOptions = Object.assign({}, t.options, {
                success: function success(media, domNode) {
                    t._meReady(media, domNode);
                                                                            Severity: Major
                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                              Function remove has 101 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                              Open

                                                                                      value: function remove() {
            var t = this,
                rendererName = t.media.rendererName,
                src = t.media.originalNode.src;
                                                                              Severity: Major
                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 4 hrs to fix

                                                                                Function setResponsiveMode has 99 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                Open

                                                                                        value: function setResponsiveMode() {
            var t = this,
                parent = function () {

                var parentEl = void 0,
                                                                                Severity: Major
                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                  Function assignGettersSetters has 94 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                  Open

                                                                                              assignGettersSetters = function assignGettersSetters(propName) {

            var capName = '' + propName.substring(0, 1).toUpperCase() + propName.substring(1);

            youtube['get' + capName] = function () {
                                                                                  Severity: Major
                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                    Function 28 has 93 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                    Open

                                                                                    },{"7":7}],28:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                    Severity: Major
                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                      `` has 30 functions (exceeds 20 allowed). Consider refactoring.
                                                                                      Open

                                                                                       */(function(){function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}return e})()({1:[function(_dereq_,module,exports){

},{}],2:[function(_dereq_,module,exports){
(function (global){
var topLevel = typeof global !== 'undefined' ? global :
                                                                                      Severity: Minor
                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                        Function 12 has 91 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                        Open

                                                                                        },{"16":16,"2":2,"25":25,"26":26,"30":30,"5":5}],12:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                                                                                        Severity: Major
                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                          Function handleMouseMove has 91 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                          Open

                                                                                                  var handleMouseMove = function handleMouseMove(e) {
            var totalStyles = getComputedStyle(t.total),
                offsetStyles = (0, _dom.offset)(t.total),
                width = t.total.offsetWidth,
                transform = function () {
                                                                                          Severity: Major
                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                            Function 17 has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
                                                                                            Open

                                                                                            },{"17":17,"2":2,"25":25,"26":26,"27":27,"28":28,"3":3,"30":30,"5":5,"6":6,"7":7}],17:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                            Severity: Minor
                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                            Cognitive Complexity

                                                                                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                            A method's cognitive complexity is based on a few simple rules:

                                                                                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                            • Code is considered more complex for each "break in the linear flow of the code"
                                                                                            • Code is considered more complex when "flow breaking structures are nested"

                                                                                            Further reading

                                                                                            Function 8 has 88 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                            Open

                                                                                            },{"3":3}],8:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                            Severity: Major
                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                              Function 15 has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                              Open

                                                                                              },{"16":16,"2":2,"25":25,"26":26,"27":27,"5":5}],15:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                              Severity: Major
                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                                Function setFillMode has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                Open

                                                                                                        value: function setFillMode() {
            var t = this;
            var isIframe = _window2.default.self !== _window2.default.top && _window2.default.frameElement !== null;
            var parent = function () {
                var parentEl = void 0,
                                                                                                Severity: Major
                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                                  Function create has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                      create: function create(mediaElement, options, mediaFiles) {

        var id = mediaElement.id + '_' + options.prefix;
        var isActive = false;
                                                                                                  Severity: Major
                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                                    Consider simplifying this complex logical expression.
                                                                                                    Open

                                                                                                                if (forceHide !== true && (!t.controlsAreVisible || t.options.alwaysShowControls || t.paused && t.readyState === 4 && (!t.options.hideVideoControlsOnLoad && t.currentTime <= 0 || !t.options.hideVideoControlsOnPause && t.currentTime > 0) || t.isVideo && !t.options.hideVideoControlsOnLoad && !t.readyState || t.ended)) {
                return;
            }
                                                                                                    Severity: Critical
                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                                      Function enterFullScreen has 75 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                          enterFullScreen: function enterFullScreen() {
        var t = this,
            isNative = t.media.rendererName !== null && /(html5|native)/i.test(t.media.rendererName),
            containerStyles = getComputedStyle(t.getElement(t.container));
                                                                                                      Severity: Major
                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 3 hrs to fix

                                                                                                        Function Renderer has 74 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                        Open

                                                                                                        var Renderer = function () {
    function Renderer() {
        _classCallCheck(this, Renderer);

        this.renderers = {};
                                                                                                        Severity: Major
                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

                                                                                                          Function 10 has 72 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                          Open

                                                                                                          },{"16":16,"2":2,"25":25,"26":26,"27":27,"28":28,"3":3,"5":5}],10:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                                                                                                          Severity: Major
                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

                                                                                                            Function secondsToTimeCode has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                            Open

                                                                                                            function secondsToTimeCode(time) {
    var forceHours = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    var showFrameCount = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
    var fps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 25;
    var secondsDecimalLength = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
                                                                                                            Severity: Major
                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

                                                                                                              Function 27 has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
                                                                                                              Open

                                                                                                              },{"2":2,"3":3,"7":7}],27:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                              Severity: Minor
                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

                                                                                                              Cognitive Complexity

                                                                                                              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                              A method's cognitive complexity is based on a few simple rules:

                                                                                                              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                              • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                              • Code is considered more complex when "flow breaking structures are nested"

                                                                                                              Further reading

                                                                                                              Function buildfullscreen has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                              Open

                                                                                                                  buildfullscreen: function buildfullscreen(player) {
        if (!player.isVideo) {
            return;
        }
                                                                                                              Severity: Major
                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

                                                                                                                Function 2 has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
                                                                                                                Open

                                                                                                                },{}],2:[function(_dereq_,module,exports){
(function (global){
var topLevel = typeof global !== 'undefined' ? global :
    typeof window !== 'undefined' ? window : {}
var minDoc = _dereq_(1);
                                                                                                                Severity: Minor
                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

                                                                                                                Cognitive Complexity

                                                                                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                                A method's cognitive complexity is based on a few simple rules:

                                                                                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                                • Code is considered more complex when "flow breaking structures are nested"

                                                                                                                Further reading

                                                                                                                Function buildplaypause has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                Open

                                                                                                                    buildplaypause: function buildplaypause(player, controls, layers, media) {
        var t = this,
            op = t.options,
            playTitle = (0, _general.isString)(op.playText) ? op.playText : _i18n2.default.t('mejs.play'),
            pauseTitle = (0, _general.isString)(op.pauseText) ? op.pauseText : _i18n2.default.t('mejs.pause'),
                                                                                                                Severity: Major
                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

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

                                                                                                                          parse: function parse(trackText) {
            var trackElem = _document2.default.adoptNode(new DOMParser().parseFromString(trackText, 'application/xml').documentElement),
                container = trackElem.querySelector('div'),
                lines = container.querySelectorAll('p'),
                styleNode = _document2.default.getElementById(container.getAttribute('style')),
                                                                                                                  Severity: Major
                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 2 hrs to fix

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

                                                                                                                        drawChapters: function drawChapters(chapters) {
        var t = this,
            total = chapters.entries.length;

        if (!total) {
                                                                                                                    Severity: Minor
                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

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

                                                                                                                          exitFullScreen: function exitFullScreen() {
        var t = this,
            isNative = t.media.rendererName !== null && /(native|html5)/i.test(t.media.rendererName);

        if (!t.isVideo) {
                                                                                                                      Severity: Minor
                                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

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

                                                                                                                        function timeCodeToSeconds(time) {
    var fps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 25;


    if (typeof time !== 'string') {
                                                                                                                        Severity: Minor
                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

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

                                                                                                                          function ajax(url, dataType, success, error) {
    var xhr = _window2.default.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');

    var type = 'application/x-www-form-urlencoded; charset=UTF-8',
        completed = false,
                                                                                                                          Severity: Minor
                                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

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

                                                                                                                                        var assignHlsEvents = function assignHlsEvents(name, data) {
                if (name === 'hlsError') {
                    console.warn(data);
                    data = data[1];
                                                                                                                            Severity: Minor
                                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                              Function changeRenderer has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                              Open

                                                                                                                                  t.mediaElement.changeRenderer = function (rendererName, mediaFiles) {

        var t = _this,
            media = Object.keys(mediaFiles[0]).length > 2 ? mediaFiles[0] : mediaFiles[0].src;
                                                                                                                              Severity: Minor
                                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                Function MediaElementPlayer has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                Open

                                                                                                                                    function MediaElementPlayer(node, o) {
        _classCallCheck(this, MediaElementPlayer);

        var t = this,
            element = typeof node === 'string' ? _document2.default.getElementById(node) : node;
                                                                                                                                Severity: Minor
                                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                  Function displayCaptions has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                  Open

                                                                                                                                      displayCaptions: function displayCaptions() {
        if (this.tracks === undefined) {
            return;
        }
                                                                                                                                  Severity: Minor
                                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                    Function setTrack has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                    Open

                                                                                                                                        setTrack: function setTrack(trackId, setByKeyboard) {

        var t = this,
            radios = t.captionsButton.querySelectorAll('input[type="radio"]'),
            captions = t.captionsButton.querySelectorAll('.' + t.options.classPrefix + 'captions-selected'),
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                      Function assignGettersSetters has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                      Open

                                                                                                                                                  assignGettersSetters = function assignGettersSetters(propName) {
            flash.flashState[propName] = null;

            var capName = '' + propName.substring(0, 1).toUpperCase() + propName.substring(1);
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                        Function onStateChange has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                                        onStateChange: function onStateChange(e) {
                    var events = [];

                    switch (e.data) {
                        case -1:
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                          Function _handleError has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                          Open

                                                                                                                                                  value: function _handleError(e, media, node) {
            var t = this,
                play = t.getElement(t.layers).querySelector('.' + t.options.classPrefix + 'overlay-play');

            if (play) {
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                            Function setSrc has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                            Open

                                                                                                                                                    setSrc = function setSrc(value) {
        var mediaFiles = [];

        if (typeof value === 'string') {
            mediaFiles.push({
                                                                                                                                            Severity: Minor
                                                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                              Function buildposter has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                              Open

                                                                                                                                                      value: function buildposter(player, controls, layers, media) {
            var t = this,
                poster = _document2.default.createElement('div');

            poster.className = t.options.classPrefix + 'poster ' + t.options.classPrefix + 'layer';
                                                                                                                                              Severity: Minor
                                                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                Function calculateTimeFormat has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                Open

                                                                                                                                                function calculateTimeFormat(time, options) {
    var fps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 25;


    time = !time || typeof time !== 'number' || time < 0 ? 0 : time;
                                                                                                                                                Severity: Minor
                                                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                  Function hideControls has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                  Open

                                                                                                                                                          value: function hideControls(doAnimation, forceHide) {
            var t = this;

            doAnimation = doAnimation === undefined || doAnimation;
                                                                                                                                                  Severity: Minor
                                                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                    Function 18 has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                    Open

                                                                                                                                                    },{"3":3}],18:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
                                                                                                                                                    Severity: Minor
                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                      Function showControls has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                      Open

                                                                                                                                                              value: function showControls(doAnimation) {
            var t = this;

            doAnimation = doAnimation === undefined || doAnimation;
                                                                                                                                                      Severity: Minor
                                                                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                        Function onReady has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                        Open

                                                                                                                                                                        onReady: function onReady(e) {
                    mediaElement.youTubeApi = youTubeApi = e.target;
                    mediaElement.youTubeState = {
                        paused: true,
                        ended: false
                                                                                                                                                        Severity: Minor
                                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                          Function assignGettersSetters has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                          Open

                                                                                                                                                                      assignGettersSetters = function assignGettersSetters(propName) {
            var capName = '' + propName.substring(0, 1).toUpperCase() + propName.substring(1);

            node['get' + capName] = function () {
                return dashPlayer !== null ? node[propName] : null;
                                                                                                                                                          Severity: Minor
                                                                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                            Open

                                                                                                                                                                        if (t.media.rendererName !== null && (/(youtube|facebook)/i.test(t.media.rendererName) && !(t.media.originalNode.getAttribute('poster') || player.options.poster || typeof t.media.renderer.getPosterUrl === 'function' && t.media.renderer.getPosterUrl()) || _constants.IS_STOCK_ANDROID || t.media.originalNode.getAttribute('autoplay'))) {
                bigPlay.style.display = 'none';
            }
                                                                                                                                                            Severity: Critical
                                                                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                              Open

                                                                                                                                                              if (!Element.prototype.matches) {
    Element.prototype.matches = Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector || function (s) {
        var matches = (this.document || this.ownerDocument).querySelectorAll(s),
            i = matches.length - 1;
        while (--i >= 0 && matches.item(i) !== this) {}
                                                                                                                                                              Severity: Critical
                                                                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                Function assignGettersSetters has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                Open

                                                                                                                                                                            assignGettersSetters = function assignGettersSetters(propName) {
            var capName = '' + propName.substring(0, 1).toUpperCase() + propName.substring(1);

            node['get' + capName] = function () {
                return flvPlayer !== null ? node[propName] : null;
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                  Function showSlide has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                  Open

                                                                                                                                                                      showSlide: function showSlide(index) {
        var _this = this;

        var t = this;
                                                                                                                                                                  Severity: Minor
                                                                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                    Function setPlayerSize has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                    Open

                                                                                                                                                                            value: function setPlayerSize(width, height) {
            var t = this;

            if (!t.options.setDimensions) {
                return false;
                                                                                                                                                                    Severity: Minor
                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                      Function select has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                      Open

                                                                                                                                                                              value: function select(mediaFiles) {
            var renderers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

            var renderersLength = renderers.length;
                                                                                                                                                                      Severity: Minor
                                                                                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                        Function 10 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                                                        Open

                                                                                                                                                                        },{"16":16,"2":2,"25":25,"26":26,"27":27,"28":28,"3":3,"5":5}],10:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                        Cognitive Complexity

                                                                                                                                                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                                                                                        A method's cognitive complexity is based on a few simple rules:

                                                                                                                                                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                                                                                        • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                                                                                        • Code is considered more complex when "flow breaking structures are nested"

                                                                                                                                                                        Further reading

                                                                                                                                                                        Function 3 has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                                                        Open

                                                                                                                                                                        },{"1":1}],3:[function(_dereq_,module,exports){
(function (global){
var win;

if (typeof window !== "undefined") {
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                        Cognitive Complexity

                                                                                                                                                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                                                                                        A method's cognitive complexity is based on a few simple rules:

                                                                                                                                                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                                                                                        • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                                                                                        • Code is considered more complex when "flow breaking structures are nested"

                                                                                                                                                                        Further reading

                                                                                                                                                                        Function positionVolumeHandle has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                        Open

                                                                                                                                                                                    positionVolumeHandle = function positionVolumeHandle(volume) {

            if (volume === null || isNaN(volume) || volume === undefined) {
                return;
            }
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                          Function setPoster has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                          Open

                                                                                                                                                                                  value: function setPoster(url) {
            var t = this;

            if (t.getElement(t.container)) {
                var posterDiv = t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'poster');
                                                                                                                                                                          Severity: Minor
                                                                                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                            Function parse has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                            Open

                                                                                                                                                                                    parse: function parse(trackText) {
            var lines = trackText.split(/\r?\n/),
                entries = [];

            var timecode = void 0,
                                                                                                                                                                            Severity: Minor
                                                                                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                              Function setControlsSize has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                              Open

                                                                                                                                                                                      value: function setControlsSize() {
            var t = this;

            if (!dom.visible(t.getElement(t.container))) {
                return;
                                                                                                                                                                              Severity: Minor
                                                                                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                                Function all has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                Open

                                                                                                                                                                                  Promise.all = function (arr) {
    var args = Array.prototype.slice.call(arr);

    return new Promise(function (resolve, reject) {
      if (args.length === 0) return resolve([]);
                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                                  Function debounce has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                  Open

                                                                                                                                                                                  function debounce(func, wait) {
    var _this = this,
        _arguments = arguments;

    var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                                    Consider simplifying this complex logical expression.
                                                                                                                                                                                    Open

                                                                                                                                                                                                if (!(_constants.IS_ANDROID && t.options.AndroidUseNativeControls) && !(_constants.IS_IPAD && t.options.iPadUseNativeControls) && !(_constants.IS_IPHONE && t.options.iPhoneUseNativeControls)) {
                if (!t.isVideo && !t.options.features.length && !t.options.useDefaultControls) {
                    if (autoplay && isNative) {
                        t.play();
                    }
                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 1 hr to fix

                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                      Open

                                                                                                                                                                                                          if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
                        to[nextKey] = nextSource[nextKey];
                    }
                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                        Open

                                                                                                                                                                                                                        if (target === t.slider || target.closest('.' + t.options.classPrefix + 'time-slider')) {
                                    handleMouseMove(event);
                                }
                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                                          Open

                                                                                                                                                                                                                          if (t.controlsEnabled) {
                                    t.showControls(false);
                                }
                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                            Open

                                                                                                                                                                                                                            if (!t.paused && !t.options.alwaysShowControls) {
                                    t.startControlsTimer(t.options.controlsTimeoutMouseLeave);
                                }
                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                                              Open

                                                                                                                                                                                                                                  if (index < total && mediaFiles[index + 1] !== undefined) {
                                        node.setSrc(mediaFiles[index++].src);
                                        node.load();
                                        node.play();
                                    } else {
                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                                                Open

                                                                                                                                                                                                                                if (!t.options.alwaysShowControls) {
                                    t.killControlsTimer('enter');
                                    t.showControls();
                                    t.startControlsTimer(t.options.controlsTimeoutMouseEnter);
                                }
                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                  if ((0, _general.isString)(options.dash.robustnessLevel) && options.dash.robustnessLevel) {
                                    dashPlayer.getProtectionController().setRobustnessLevel(options.dash.robustnessLevel);
                                }
                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (!t.mediaElement.renderer.paused) {
                                            t.mediaElement.renderer.pause();
                                        }
                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                      if (!t.options.alwaysShowControls) {
                                    t.startControlsTimer(t.options.controlsTimeoutMouseEnter);
                                }
                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                        if (!t.controlsAreVisible) {
                                    t.showControls();
                                }
                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 45 mins to fix

                                                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                                                          Open

                                                                                                                                                                                                                      } else if (_constants.IS_IPAD && t.options.iPadUseNativeControls || _constants.IS_IPHONE && t.options.iPhoneUseNativeControls || _constants.IS_ANDROID && t.options.AndroidUseNativeControls) {
                t.media.originalNode.poster = url;
            }
                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 40 mins to fix

                                                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                                                            Open

                                                                                                                                                                                                                    if (t.options.useFakeFullscreen === false && (Features.IS_IOS || Features.IS_SAFARI) && Features.HAS_IOS_FULLSCREEN && typeof t.media.originalNode.webkitEnterFullscreen === 'function' && t.media.originalNode.canPlayType((0, _media.getTypeFromFile)(t.media.getSrc()))) {
            t.media.originalNode.webkitEnterFullscreen();
            return;
        }
                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 40 mins to fix

                                                                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                                                                              Open

                                                                                                                                                                                                                          } else if ((t.isVideo || !t.isVideo && (t.options.features.length || t.options.useDefaultControls)) && !(_constants.IS_ANDROID && t.options.AndroidUseNativeControls)) {
                t.node.removeAttribute('controls');
                var videoPlayerTitle = t.isVideo ? _i18n2.default.t('mejs.video-player') : _i18n2.default.t('mejs.audio-player');

                var offscreen = _document2.default.createElement('span');
                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 40 mins to fix

                                                                                                                                                                                                                Consider simplifying this complex logical expression.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                            if (t.getElement(t.container).parentNode.length > 0 && t.getElement(t.container).parentNode.tagName.toLowerCase() === 'body') {
                parentWidth = _window2.default.innerWidth || _document2.default.documentElement.clientWidth || _document2.default.body.clientWidth;
                newHeight = _window2.default.innerHeight || _document2.default.documentElement.clientHeight || _document2.default.body.clientHeight;
            }
                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 40 mins to fix

                                                                                                                                                                                                                  Function addPlugin has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                      addPlugin: function addPlugin(p, pluginName, mimeType, activeX, axDetect) {
                                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 35 mins to fix

                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            return arguments.length <= 6 ? undefined : arguments[6];
                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                  return 'application/dash+xml';
                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                      Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                    return null;
                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                        Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                  return arguments.length <= 5 ? undefined : arguments[5];
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                        return 'video/flv';
                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                            Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                  return 'transform';
                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                              Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                        return false;
                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                          return arguments.length <= 5 ? undefined : arguments[5];
                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                  Found in wp-includes/js/mediaelement/mediaelement-and-player.js - About 30 mins to fix

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"15":15,"27":27,"7":7}],6:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 mo to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 553..1006

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 5145.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{}],5:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 mo to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 286..553

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 4978.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],20:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 1489..1931

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 4313.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"2":2,"25":25,"27":27,"3":3,"7":7,"8":8}],24:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 2616..3155

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 4272.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],22:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 2180..2469

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 2634.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"16":16,"3":3,"7":7}],19:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 1242..1489

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 2465.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"2":2,"25":25,"27":27,"28":28,"3":3,"5":5,"7":7,"8":8}],21:[function(_dereq_,module,exports){
'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 1931..2180

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 2413.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"2":2,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],25:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 3155..3341

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 2378.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"2":2,"3":3,"7":7}],26:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 3341..3570

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 2112.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{}],4:[function(_dereq_,module,exports){
(function (root) {

  // Store setTimeout reference so promise-polyfill will be unaffected by
  // other code modifying setTimeout (like sinon.useFakeTimers())
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 51..286

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 1725.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"27":27,"7":7}],29:[function(_dereq_,module,exports){
'use strict';

var _document = _dereq_(2);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 3831..3984

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 1495.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"25":25,"26":26,"27":27,"28":28,"3":3,"7":7,"8":8}],23:[function(_dereq_,module,exports){
'use strict';

var _window = _dereq_(3);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 2469..2616

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 1324.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"3":3}],8:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 1038..1152

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 1155.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"2":2,"3":3,"7":7}],27:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 3570..3706

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 1047.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"7":7}],28:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 3706..3831

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 1001.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"16":16,"2":2,"25":25,"26":26,"27":27,"5":5}],15:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 1152..1242

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 416.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                     */(function(){function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}return e})()({1:[function(_dereq_,module,exports){

},{}],2:[function(_dereq_,module,exports){
(function (global){
var topLevel = typeof global !== 'undefined' ? global :
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 11..3984
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/renderers/vimeo.js on lines 11..432

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 304.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'globalUnbind',
        value: function globalUnbind(events, callback) {
            var t = this,
                doc = t.node ? t.node.ownerDocument : _document2.default;
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4766..4792

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 300.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'globalBind',
        value: function globalBind(events, callback) {
            var t = this,
                doc = t.node ? t.node.ownerDocument : _document2.default;
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4792..4818

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 300.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (doAnimation) {
                (function () {
                    dom.fadeIn(t.getElement(t.controls), 200, function () {
                        dom.removeClass(t.getElement(t.controls), t.options.classPrefix + 'offscreen');
                        var event = (0, _general.createEvent)('controlsshown', t.getElement(t.container));
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3898..3933

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 270.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (doAnimation) {
                (function () {
                    dom.fadeOut(t.getElement(t.controls), 200, function () {
                        dom.addClass(t.getElement(t.controls), t.options.classPrefix + 'offscreen');
                        t.getElement(t.controls).style.display = '';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3849..3882

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 270.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"2":2,"25":25,"27":27,"28":28,"3":3,"7":7,"8":8}],7:[function(_dereq_,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 1006..1038

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 254.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (t.options[tagType + 'Width'] > 0 || t.options[tagType + 'Width'].toString().indexOf('%') > -1) {
                    t.width = t.options[tagType + 'Width'];
                } else if (t.node.style.width !== '' && t.node.style.width !== null) {
                    t.width = t.node.style.width;
                } else if (t.node.getAttribute('width')) {
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3809..3817

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 224.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (t.options[tagType + 'Height'] > 0 || t.options[tagType + 'Height'].toString().indexOf('%') > -1) {
                    t.height = t.options[tagType + 'Height'];
                } else if (t.node.style.height !== '' && t.node.style.height !== null) {
                    t.height = t.node.style.height;
                } else if (t.node.getAttribute('height')) {
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3799..3807

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 224.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    parent = function () {

                var parentEl = void 0,
                    el = t.getElement(t.container);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4508..4530

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 199.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                var parent = function () {
                var parentEl = void 0,
                    el = t.getElement(t.container);

                while (el) {
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4389..4412

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 199.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{}],2:[function(_dereq_,module,exports){
(function (global){
var topLevel = typeof global !== 'undefined' ? global :
    typeof window !== 'undefined' ? window : {}
var minDoc = _dereq_(1);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 13..34

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 195.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    },{"1":1}],3:[function(_dereq_,module,exports){
(function (global){
var win;

if (typeof window !== "undefined") {
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement.js on lines 34..51

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 162.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                for (var _i6 = 0, _total4 = labels.length; _i6 < _total4; _i6++) {
                labels[_i6].addEventListener('click', function (e) {
                    var radio = (0, _dom.siblings)(this, function (el) {
                        return el.tagName === 'INPUT';
                    })[0],
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2806..2815

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 132.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            for (var _i15 = 0, _total12 = labels.length; _i15 < _total12; _i15++) {
            labels[_i15].addEventListener('click', function (e) {
                var radio = (0, _dom.siblings)(this, function (el) {
                    return el.tagName === 'INPUT';
                })[0],
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2393..2402

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 132.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    nativeHeight = function () {
                if (t.isVideo) {
                    if (t.node.videoHeight && t.node.videoHeight > 0) {
                        return t.node.videoHeight;
                    } else if (t.node.getAttribute('height')) {
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4414..4426

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 131.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    nativeWidth = function () {
                if (t.isVideo) {
                    if (t.node.videoWidth && t.node.videoWidth > 0) {
                        return t.node.videoWidth;
                    } else if (t.node.getAttribute('width')) {
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4427..4439

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 131.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3523..3523

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 113.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1181..1181

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 113.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (!player.options.loop) {
                (0, _dom.removeClass)(play, t.options.classPrefix + 'pause');
                (0, _dom.removeClass)(play, t.options.classPrefix + 'play');
                (0, _dom.addClass)(play, t.options.classPrefix + 'replay');
                playBtn.setAttribute('title', playTitle);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1507..1520

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 109.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if ('play' === which) {
                (0, _dom.removeClass)(play, t.options.classPrefix + 'play');
                (0, _dom.removeClass)(play, t.options.classPrefix + 'replay');
                (0, _dom.addClass)(play, t.options.classPrefix + 'pause');
                playBtn.setAttribute('title', pauseTitle);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1540..1546

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 109.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                for (var _i3 = 0, _total = inEvents.length; _i3 < _total; _i3++) {
                player.captionsButton.addEventListener(inEvents[_i3], function () {
                    (0, _dom.removeClass)(this.querySelector('.' + t.options.classPrefix + 'captions-selector'), t.options.classPrefix + 'offscreen');
                });
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2380..2384
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2417..2421

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 108.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                for (var _i4 = 0, _total2 = outEvents.length; _i4 < _total2; _i4++) {
                player.captionsButton.addEventListener(outEvents[_i4], function () {
                    (0, _dom.addClass)(this.querySelector('.' + t.options.classPrefix + 'captions-selector'), t.options.classPrefix + 'offscreen');
                });
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2374..2378
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2417..2421

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 108.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            for (var _i8 = 0, _total6 = outEvents.length; _i8 < _total6; _i8++) {
            player.chaptersButton.addEventListener(outEvents[_i8], function () {
                (0, _dom.addClass)(this.querySelector('.' + t.options.classPrefix + 'chapters-selector'), t.options.classPrefix + 'offscreen');
            });
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2374..2378
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2380..2384

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 108.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                        if (t.options.success) {

                        if (typeof t.options.success === 'string') {
                            _window2.default[t.options.success](t.media, t.domNode, t);
                        } else {
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4275..4281

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 98.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (t.options.success) {
                if (typeof t.options.success === 'string') {
                    _window2.default[t.options.success](t.media, t.domNode, t);
                } else {
                    t.options.success(t.media, t.domNode, t);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4026..4033

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 98.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (timecode.length > 5) {
            (0, _dom.addClass)(t.getElement(t.container), t.options.classPrefix + 'long-video');
        } else {
            (0, _dom.removeClass)(t.getElement(t.container), t.options.classPrefix + 'long-video');
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2231..2235

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 97.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (timecode.length > 5) {
            (0, _dom.addClass)(t.getElement(t.container), t.options.classPrefix + 'long-video');
        } else {
            (0, _dom.removeClass)(t.getElement(t.container), t.options.classPrefix + 'long-video');
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2206..2210

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 97.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                } else {
                (0, _dom.removeClass)(mute, t.options.classPrefix + 'unmute');
                (0, _dom.addClass)(mute, t.options.classPrefix + 'mute');
                var _button = mute.firstElementChild;
                _button.setAttribute('title', muteText);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3157..3163

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 92.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (volume === 0) {
                (0, _dom.removeClass)(mute, t.options.classPrefix + 'mute');
                (0, _dom.addClass)(mute, t.options.classPrefix + 'unmute');
                var button = mute.firstElementChild;
                button.setAttribute('title', unmuteText);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3163..3169

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 92.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                volumeHandle = mode === 'vertical' ? t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'volume-handle') : t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'horizontal-volume-handle'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3144..3144
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3145..3145
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3146..3146

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 87.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                volumeCurrent = mode === 'vertical' ? t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'volume-current') : t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'horizontal-volume-current'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3144..3144
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3145..3145
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3147..3147

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 87.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                volumeTotal = mode === 'vertical' ? t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'volume-total') : t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'horizontal-volume-total'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3144..3144
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3146..3146
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3147..3147

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 87.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            var volumeSlider = mode === 'vertical' ? t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'volume-slider') : t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'horizontal-volume-slider'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3145..3145
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3146..3146
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3147..3147

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 87.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            player.chaptersButton.innerHTML = '<button type="button" aria-controls="' + t.id + '" title="' + chaptersTitle + '" aria-label="' + chaptersTitle + '" tabindex="0"></button>' + ('<div class="' + t.options.classPrefix + 'chapters-selector ' + t.options.classPrefix + 'offscreen">') + ('<ul class="' + t.options.classPrefix + 'chapters-selector-list"></ul>') + '</div>';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2321..2321

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 86.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            player.captionsButton.innerHTML = '<button type="button" aria-controls="' + t.id + '" title="' + tracksTitle + '" aria-label="' + tracksTitle + '" tabindex="0"></button>' + ('<div class="' + t.options.classPrefix + 'captions-selector ' + t.options.classPrefix + 'offscreen">') + ('<ul class="' + t.options.classPrefix + 'captions-selector-list">') + ('<li class="' + t.options.classPrefix + 'captions-selector-list-item">') + ('<input type="radio" class="' + t.options.classPrefix + 'captions-selector-input" ') + ('name="' + player.id + '_captions" id="' + player.id + '_captions_none" ') + 'value="none" checked disabled>' + ('<label class="' + t.options.classPrefix + 'captions-selector-label ') + (t.options.classPrefix + 'captions-selected" ') + ('for="' + player.id + '_captions_none">' + _i18n2.default.t('mejs.none') + '</label>') + '</li>' + '</ul>' + '</div>';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2329..2329

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 86.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (mode === 'vertical') {
                volumeCurrent.style.bottom = 0;
                volumeCurrent.style.height = volumePercentage;
                volumeHandle.style.bottom = volumePercentage;
                volumeHandle.style.marginBottom = -parseFloat(volumeStyles.height) / 2 + 'px';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3179..3184

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 81.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                } else {
                volumeCurrent.style.left = 0;
                volumeCurrent.style.width = volumePercentage;
                volumeHandle.style.left = volumePercentage;
                volumeHandle.style.marginLeft = -parseFloat(volumeStyles.width) / 2 + 'px';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3174..3179

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 81.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    for (var i = 0; i < _total2; i++) {
                    elements[i].style.width = t.normalWidth + 'px';
                    elements[i].style.height = t.normalHeight + 'px';
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1433..1436

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 77.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                for (var _i2 = 0; _i2 < total; _i2++) {
                layers[_i2].style.width = t.normalWidth + 'px';
                layers[_i2].style.height = t.normalHeight + 'px';
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1421..1424

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 77.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (t.fullscreenBtn) {
            (0, _dom.removeClass)(t.fullscreenBtn, t.options.classPrefix + 'unfullscreen');
            (0, _dom.addClass)(t.fullscreenBtn, t.options.classPrefix + 'fullscreen');
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1376..1379

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 73.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (t.fullscreenBtn) {
            (0, _dom.removeClass)(t.fullscreenBtn, t.options.classPrefix + 'fullscreen');
            (0, _dom.addClass)(t.fullscreenBtn, t.options.classPrefix + 'unfullscreen');
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1439..1442

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 73.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (!_temp.stop && lines[_i16 + 1].getAttribute('begin')) {
                    _temp.stop = (0, _time.convertSMPTEtoSeconds)(lines[_i16 + 1].getAttribute('begin'));
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2977..2979

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 71.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (!_temp.start && lines[_i16 - 1].getAttribute('end')) {
                    _temp.start = (0, _time.convertSMPTEtoSeconds)(lines[_i16 - 1].getAttribute('end'));
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2983..2985

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 71.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                duration.innerHTML = '<span class="' + t.options.classPrefix + 'duration">' + ((0, _time.secondsToTimeCode)(t.options.duration, t.options.alwaysShowHours, t.options.showTimecodeFrameCount, t.options.framesPerSecond, t.options.secondsDecimalLength, t.options.timeFormat) + '</span>');
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2171..2171

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 70.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                controls.querySelector('.' + t.options.classPrefix + 'time').innerHTML += t.options.timeAndDurationSeparator + '<span class="' + t.options.classPrefix + 'duration">' + ((0, _time.secondsToTimeCode)(t.options.duration, t.options.alwaysShowHours, t.options.showTimecodeFrameCount, t.options.framesPerSecond, t.options.secondsDecimalLength, t.options.timeFormat) + '</span>');
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2179..2179

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 70.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                media.addEventListener('playing', function () {
                bigPlay.style.display = 'none';
                loading.style.display = 'none';
                error.style.display = 'none';
                hasError = false;
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4946..4951

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 69.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                media.addEventListener('play', function () {
                bigPlay.style.display = 'none';
                loading.style.display = 'none';
                error.style.display = 'none';
                hasError = false;
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4952..4957

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 69.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    t.getElement(t.container).addEventListener('mousemove', function (event) {
                    var target = event.target;
                    if (target === t.slider || target.closest('.' + t.options.classPrefix + 'time-slider')) {
                        handleMouseMove(event);
                    }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1942..1947

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 68.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                t.getElement(t.container).addEventListener(endEvents[j], function (event) {
                                var target = event.target;
                                if (target === t.slider || target.closest('.' + t.options.classPrefix + 'time-slider')) {
                                    handleMouseMove(event);
                                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1962..1967

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 68.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (!media.paused) {
                    (0, _dom.removeClass)(player.getElement(player.container).querySelector('.' + t.options.classPrefix + 'captions-position'), t.options.classPrefix + 'captions-position-hover');
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2428..2430
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2437..2439

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 66.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            } else {
            (0, _dom.addClass)(player.getElement(player.container).querySelector('.' + t.options.classPrefix + 'captions-position'), t.options.classPrefix + 'captions-position-hover');
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2428..2430
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2433..2435

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 66.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                player.getElement(player.container).addEventListener('controlsshown', function () {
                (0, _dom.addClass)(player.getElement(player.container).querySelector('.' + t.options.classPrefix + 'captions-position'), t.options.classPrefix + 'captions-position-hover');
            });
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2433..2435
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2437..2439

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 66.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (t.node.style.height !== 'none' && t.node.style.height !== t.height) {
                t.node.style.height = 'auto';
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4536..4538
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4540..4542

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 66.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (t.node.style.maxWidth !== 'none' && t.node.style.maxWidth !== t.width) {
                t.node.style.maxWidth = 'none';
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4533..4535
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4540..4542

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 66.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (t.node.style.maxHeight !== 'none' && t.node.style.maxHeight !== t.height) {
                t.node.style.maxHeight = 'none';
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4533..4535
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4536..4538

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 66.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            var timecode = (0, _time.secondsToTimeCode)(currentTime, t.options.alwaysShowHours, t.options.showTimecodeFrameCount, t.options.framesPerSecond, t.options.secondsDecimalLength, t.options.timeFormat);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2229..2229

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 63.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            for (var _i10 = 0, _total8 = labels.length; _i10 < _total8; _i10++) {
            (0, _dom.addClass)(labels[_i10], t.options.classPrefix + 'captions-selected');
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2509..2511

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 63.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            var timecode = (0, _time.secondsToTimeCode)(duration, t.options.alwaysShowHours, t.options.showTimecodeFrameCount, t.options.framesPerSecond, t.options.secondsDecimalLength, t.options.timeFormat);
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2204..2204

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 63.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            for (var _i9 = 0, _total7 = captions.length; _i9 < _total7; _i9++) {
            (0, _dom.removeClass)(captions[_i9], t.options.classPrefix + 'captions-selected');
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2517..2519

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 63.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                for (var i = 0; i < _total; i++) {
                elements[i].style.width = '100%';
                elements[i].style.height = '100%';
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1371..1374

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 61.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            for (var _i = 0; _i < total; _i++) {
            layers[_i].style.width = '100%';
            layers[_i].style.height = '100%';
        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1359..1362

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 61.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    t.getElement(t.container).innerHTML = '<div class="' + t.options.classPrefix + 'inner">' + ('<div class="' + t.options.classPrefix + 'mediaelement"></div>') + ('<div class="' + t.options.classPrefix + 'layers"></div>') + ('<div class="' + t.options.classPrefix + 'controls"></div>') + '</div>';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1591..1591

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 58.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                tooltip = player.options.enableProgressTooltip ? '<span class="' + t.options.classPrefix + 'time-float">' + ('<span class="' + t.options.classPrefix + 'time-float-current">00:00</span>') + ('<span class="' + t.options.classPrefix + 'time-float-corner"></span>') + '</span>' : '',
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3748..3748

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 58.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                        var button = t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'overlay-button'),
                        pressed = button.getAttribute('aria-pressed');
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4065..4066

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                var button = t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'overlay-button'),
                                pressed = button.getAttribute('aria-pressed');
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4914..4915

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            mute.addEventListener('mouseleave', function () {
            mouseIsOver = false;
            if (!mouseIsDown && mode === 'vertical') {
                volumeSlider.style.display = 'none';
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3309..3314
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3323..3328

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                t.globalBind('mouseup.vol', function () {
                mouseIsDown = false;
                if (!mouseIsOver && mode === 'vertical') {
                    volumeSlider.style.display = 'none';
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3259..3264
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3309..3314

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            volumeSlider.addEventListener('focusout', function () {
            mouseIsOver = false;
            if (!mouseIsDown && mode === 'vertical') {
                volumeSlider.style.display = 'none';
            }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3259..3264
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3323..3328

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            play.className = t.options.classPrefix + 'button ' + t.options.classPrefix + 'playpause-button ' + t.options.classPrefix + 'play';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3059..3059
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4909..4909

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 55.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                bigPlay.className = t.options.classPrefix + 'overlay ' + t.options.classPrefix + 'layer ' + t.options.classPrefix + 'overlay-play';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1493..1493
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3059..3059

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 55.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            mute.className = t.options.classPrefix + 'button ' + t.options.classPrefix + 'volume-button ' + t.options.classPrefix + 'mute';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1493..1493
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4909..4909

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 55.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'src',
        set: function set(src) {
            this.setSrc(src);
        },
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5275..5283
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5288..5296
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5451..5459
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5469..5477
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5477..5485

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'currentTime',
        set: function set(time) {
            this.setCurrentTime(time);
        },
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5288..5296
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5296..5304
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5451..5459
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5469..5477
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5477..5485

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'volume',
        set: function set(volume) {
            this.setVolume(volume);
        },
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5275..5283
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5296..5304
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5451..5459
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5469..5477
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5477..5485

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'volume',
        set: function set(volume) {
            this.setVolume(volume);
        },
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5275..5283
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5288..5296
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5296..5304
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5451..5459
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5477..5485

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'src',
        set: function set(src) {
            this.setSrc(src);
        },
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5275..5283
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5288..5296
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5296..5304
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5451..5459
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5469..5477

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                        }, {
        key: 'currentTime',
        set: function set(time) {
            this.setCurrentTime(time);
        },
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5275..5283
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5288..5296
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5296..5304
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5469..5477
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5477..5485

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                        if (hoverScaleX >= 0) {
                        (0, _dom.removeClass)(t.hovered, 'negative');
                    } else {
                        (0, _dom.addClass)(t.hovered, 'negative');
                    }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1751..1755

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                            if (hoverScaleX >= 0) {
                            (0, _dom.removeClass)(t.hovered, 'negative');
                        } else {
                            (0, _dom.addClass)(t.hovered, 'negative');
                        }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2110..2114

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (lines[_i16].getAttribute('begin')) {
                    _temp.start = (0, _time.convertSMPTEtoSeconds)(lines[_i16].getAttribute('begin'));
                }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2980..2982

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (lines[_i16].getAttribute('end')) {
                    _temp.stop = (0, _time.convertSMPTEtoSeconds)(lines[_i16].getAttribute('end'));
                }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2974..2976

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (mouseIsDown && t.getCurrentTime() !== null && t.newTime.toFixed(4) !== t.getCurrentTime().toFixed(4)) {
                t.setCurrentTime(t.newTime);
                t.setCurrentRailHandle(t.newTime);
                t.updateCurrent(t.newTime);
            }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1733..1736

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (mouseIsDown && t.getCurrentTime() !== null && t.newTime.toFixed(4) !== t.getCurrentTime().toFixed(4)) {
                    t.setCurrentRailHandle(t.newTime);
                    t.updateCurrent(t.newTime);
                }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1816..1820

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            var labels = (0, _dom.siblings)(track, function (el) {
            return (0, _dom.hasClass)(el, t.options.classPrefix + 'captions-selector-label');
        });
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2600..2602

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            var targetSiblings = (0, _dom.siblings)(target, function (el) {
            return (0, _dom.hasClass)(el, t.options.classPrefix + 'captions-selector-label');
        });
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2514..2516

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'captions-position').style.bottom = '';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3763..3763
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4009..4009

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 51.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'overlay-play').style.display = '';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1451..1451
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3763..3763

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 51.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                        t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'controls').style.display = 'none';
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1451..1451
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4009..4009

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 51.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (t.getElement(t.controls).querySelector('.' + t.options.classPrefix + 'duration') && duration > 0) {
            t.getElement(t.controls).querySelector('.' + t.options.classPrefix + 'duration').innerHTML = timecode;
        }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2212..2214

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 51.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (t.getElement(t.controls).querySelector('.' + t.options.classPrefix + 'currenttime')) {
            t.getElement(t.controls).querySelector('.' + t.options.classPrefix + 'currenttime').innerText = timecode;
        }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2237..2239

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 51.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                tracksTitle = (0, _general.isString)(t.options.tracksText) ? t.options.tracksText : _i18n2.default.t('mejs.captions-subtitles'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1216..1216
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2300..2300
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3054..3054
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3055..3055
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3056..3056

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                unmuteText = (0, _general.isString)(t.options.unmuteText) ? t.options.unmuteText : _i18n2.default.t('mejs.unmute'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1216..1216
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2299..2299
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2300..2300
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3054..3054
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3056..3056

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                volumeControlText = (0, _general.isString)(t.options.allyVolumeControlText) ? t.options.allyVolumeControlText : _i18n2.default.t('mejs.volume-help-text'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1216..1216
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2299..2299
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2300..2300
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3054..3054
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3055..3055

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                fullscreenTitle = (0, _general.isString)(t.options.fullscreenText) ? t.options.fullscreenText : _i18n2.default.t('mejs.fullscreen'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2299..2299
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2300..2300
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3054..3054
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3055..3055
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3056..3056

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                muteText = (0, _general.isString)(t.options.muteText) ? t.options.muteText : _i18n2.default.t('mejs.mute'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1216..1216
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2299..2299
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2300..2300
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3055..3055
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3056..3056

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                chaptersTitle = (0, _general.isString)(t.options.chaptersText) ? t.options.chaptersText : _i18n2.default.t('mejs.captions-chapters'),
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 5 other locations - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 1216..1216
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2299..2299
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3054..3054
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3055..3055
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3056..3056

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (label === '') {
            label = _i18n2.default.t(_mejs2.default.language.codes[lang]) || lang;
        }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2624..2626

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                            if (label === '') {
            label = _i18n2.default.t(_mejs2.default.language.codes[lang]) || lang;
        }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 2596..2598

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                height = (0, _general.isString)(height) && height.indexOf('%') > -1 ? height : parseFloat(height) + 'px';
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4605..4605

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (!isIframe && !parseFloat(parentStyles.height)) {
                parent.style.height = t.media.offsetHeight + 'px';
            }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4556..4558

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (nativeHeight) {
                if (nativeHeight.indexOf('%') === -1) {
                    nativeHeight = nativeHeight + 'px';
                }
            } else {
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5149..5155

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                width = (0, _general.isString)(width) && width.indexOf('%') > -1 ? width : parseFloat(width) + 'px';
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4606..4606

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (!isIframe && !parseFloat(parentStyles.width)) {
                parent.style.width = t.media.offsetWidth + 'px';
            }
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4560..4562

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                if (nativeWidth) {
                if (nativeWidth.indexOf('%') === -1) {
                    nativeWidth = nativeWidth + 'px';
                }
            } else {
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 5157..5163

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 50.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (_constants.IS_IPHONE) {
                    dom.addClass(t.getElement(t.container), t.options.classPrefix + 'iphone');
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3775..3777
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3778..3780
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3781..3783

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (_constants.IS_ANDROID) {
                    dom.addClass(t.getElement(t.container), t.options.classPrefix + 'android');
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3778..3780
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3781..3783
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3784..3786

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (_constants.IS_IPAD) {
                    dom.addClass(t.getElement(t.container), t.options.classPrefix + 'ipad');
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3775..3777
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3778..3780
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3784..3786

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    if (_constants.IS_IOS) {
                    dom.addClass(t.getElement(t.container), t.options.classPrefix + 'ios');
                }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 3 other locations - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3775..3777
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3781..3783
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3784..3786

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    parentWidth = _window2.default.innerWidth || _document2.default.documentElement.clientWidth || _document2.default.body.clientWidth;
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4482..4482

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    t.controls = t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'controls');
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3794..3794

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    newHeight = _window2.default.innerHeight || _document2.default.documentElement.clientHeight || _document2.default.body.clientHeight;
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 4481..4481

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                    t.layers = t.getElement(t.container).querySelector('.' + t.options.classPrefix + 'layers');
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in wp-includes/js/mediaelement/mediaelement-and-player.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                    wp-includes/js/mediaelement/mediaelement-and-player.js on lines 3793..3793

                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                    There are no issues that match your filters.

                                                                                                                                                                                                                                    Category
                                                                                                                                                                                                                                    Status