Code Duplication - butcherman/Tech_Bench - Measure and Improve Code Quality continuously with Scrutinizer


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };


        Object.freeze(me);
      return me;
    }();
    var some = function (a) {
      var constant_a = function () {
        return a;
      };
      var self = function () {
        return me;
      };
      var map = function (f) {
        return some(f(a));
      };
      var bind = function (f) {
        return f(a);
      };
      var me = {
        fold: function (n, s) {
          return s(a);
        },
        is: function (v) {
          return a === v;
        },
        isSome: always$1,
        isNone: never$1,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        getOrNull: constant_a,
        getOrUndefined: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function (fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(never$1, function (b) {
            return elementEq(a, b);
          });
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    };
    var from = function (value) {
      return value === null || value === undefined ? NONE : some(value);
    };

		@@ 625-686 (lines=62) @@
622		Object.freeze(me);
623		return me;
624		}();
625		var some = function (a) {
626		var constant_a = function () {
627		return a;
628		};
629		var self = function () {
630		return me;
631		};
632		var map = function (f) {
633		return some(f(a));
634		};
635		var bind = function (f) {
636		return f(a);
637		};
638		var me = {
639		fold: function (n, s) {
640		return s(a);
641		},
642		is: function (v) {
643		return a === v;
644		},
645		isSome: always$1,
646		isNone: never$1,
647		getOr: constant_a,
648		getOrThunk: constant_a,
649		getOrDie: constant_a,
650		getOrNull: constant_a,
651		getOrUndefined: constant_a,
652		or: self,
653		orThunk: self,
654		map: map,
655		ap: function (optfab) {
656		return optfab.fold(none, function (fab) {
657		return some(fab(a));
658		});
659		},
660		each: function (f) {
661		f(a);
662		},
663		bind: bind,
664		flatten: constant_a,
665		exists: bind,
666		forall: bind,
667		filter: function (f) {
668		return f(a) ? me : NONE;
669		},
670		equals: function (o) {
671		return o.is(a);
672		},
673		equals_: function (o, elementEq) {
674		return o.fold(never$1, function (b) {
675		return elementEq(a, b);
676		});
677		},
678		toArray: function () {
679		return [a];
680		},
681		toString: function () {
682		return 'some(' + a + ')';
683		}
684		};
685		return me;
686		};
687		var from = function (value) {
688		return value === null \|\| value === undefined ? NONE : some(value);
689		};

		@@ 318-379 (lines=62) @@
315		Object.freeze(me);
316		return me;
317		}();
318		var some = function (a) {
319		var constant_a = function () {
320		return a;
321		};
322		var self = function () {
323		return me;
324		};
325		var map = function (f) {
326		return some(f(a));
327		};
328		var bind = function (f) {
329		return f(a);
330		};
331		var me = {
332		fold: function (n, s) {
333		return s(a);
334		},
335		is: function (v) {
336		return a === v;
337		},
338		isSome: always$1,
339		isNone: never$1,
340		getOr: constant_a,
341		getOrThunk: constant_a,
342		getOrDie: constant_a,
343		getOrNull: constant_a,
344		getOrUndefined: constant_a,
345		or: self,
346		orThunk: self,
347		map: map,
348		ap: function (optfab) {
349		return optfab.fold(none, function (fab) {
350		return some(fab(a));
351		});
352		},
353		each: function (f) {
354		f(a);
355		},
356		bind: bind,
357		flatten: constant_a,
358		exists: bind,
359		forall: bind,
360		filter: function (f) {
361		return f(a) ? me : NONE;
362		},
363		equals: function (o) {
364		return o.is(a);
365		},
366		equals_: function (o, elementEq) {
367		return o.fold(never$1, function (b) {
368		return elementEq(a, b);
369		});
370		},
371		toArray: function () {
372		return [a];
373		},
374		toString: function () {
375		return 'some(' + a + ')';
376		}
377		};
378		return me;
379		};
380		var from = function (value) {
381		return value === null \|\| value === undefined ? NONE : some(value);
382		};

		@@ 296-357 (lines=62) @@
293		Object.freeze(me);
294		return me;
295		}();
296		var some = function (a) {
297		var constant_a = function () {
298		return a;
299		};
300		var self = function () {
301		return me;
302		};
303		var map = function (f) {
304		return some(f(a));
305		};
306		var bind = function (f) {
307		return f(a);
308		};
309		var me = {
310		fold: function (n, s) {
311		return s(a);
312		},
313		is: function (v) {
314		return a === v;
315		},
316		isSome: always$1,
317		isNone: never$1,
318		getOr: constant_a,
319		getOrThunk: constant_a,
320		getOrDie: constant_a,
321		getOrNull: constant_a,
322		getOrUndefined: constant_a,
323		or: self,
324		orThunk: self,
325		map: map,
326		ap: function (optfab) {
327		return optfab.fold(none, function (fab) {
328		return some(fab(a));
329		});
330		},
331		each: function (f) {
332		f(a);
333		},
334		bind: bind,
335		flatten: constant_a,
336		exists: bind,
337		forall: bind,
338		filter: function (f) {
339		return f(a) ? me : NONE;
340		},
341		equals: function (o) {
342		return o.is(a);
343		},
344		equals_: function (o, elementEq) {
345		return o.fold(never$1, function (b) {
346		return elementEq(a, b);
347		});
348		},
349		toArray: function () {
350		return [a];
351		},
352		toString: function () {
353		return 'some(' + a + ')';
354		}
355		};
356		return me;
357		};
358		var from = function (value) {
359		return value === null \|\| value === undefined ? NONE : some(value);
360		};

		@@ 224-285 (lines=62) @@
221		Object.freeze(me);
222		return me;
223		}();
224		var some = function (a) {
225		var constant_a = function () {
226		return a;
227		};
228		var self = function () {
229		return me;
230		};
231		var map = function (f) {
232		return some(f(a));
233		};
234		var bind = function (f) {
235		return f(a);
236		};
237		var me = {
238		fold: function (n, s) {
239		return s(a);
240		},
241		is: function (v) {
242		return a === v;
243		},
244		isSome: always$1,
245		isNone: never$1,
246		getOr: constant_a,
247		getOrThunk: constant_a,
248		getOrDie: constant_a,
249		getOrNull: constant_a,
250		getOrUndefined: constant_a,
251		or: self,
252		orThunk: self,
253		map: map,
254		ap: function (optfab) {
255		return optfab.fold(none, function (fab) {
256		return some(fab(a));
257		});
258		},
259		each: function (f) {
260		f(a);
261		},
262		bind: bind,
263		flatten: constant_a,
264		exists: bind,
265		forall: bind,
266		filter: function (f) {
267		return f(a) ? me : NONE;
268		},
269		equals: function (o) {
270		return o.is(a);
271		},
272		equals_: function (o, elementEq) {
273		return o.fold(never$1, function (b) {
274		return elementEq(a, b);
275		});
276		},
277		toArray: function () {
278		return [a];
279		},
280		toString: function () {
281		return 'some(' + a + ')';
282		}
283		};
284		return me;
285		};
286		var from = function (value) {
287		return value === null \|\| value === undefined ? NONE : some(value);
288		};

		@@ 171-232 (lines=62) @@
168		Object.freeze(me);
169		return me;
170		}();
171		var some = function (a) {
172		var constant_a = function () {
173		return a;
174		};
175		var self = function () {
176		return me;
177		};
178		var map = function (f) {
179		return some(f(a));
180		};
181		var bind = function (f) {
182		return f(a);
183		};
184		var me = {
185		fold: function (n, s) {
186		return s(a);
187		},
188		is: function (v) {
189		return a === v;
190		},
191		isSome: always$1,
192		isNone: never$1,
193		getOr: constant_a,
194		getOrThunk: constant_a,
195		getOrDie: constant_a,
196		getOrNull: constant_a,
197		getOrUndefined: constant_a,
198		or: self,
199		orThunk: self,
200		map: map,
201		ap: function (optfab) {
202		return optfab.fold(none, function (fab) {
203		return some(fab(a));
204		});
205		},
206		each: function (f) {
207		f(a);
208		},
209		bind: bind,
210		flatten: constant_a,
211		exists: bind,
212		forall: bind,
213		filter: function (f) {
214		return f(a) ? me : NONE;
215		},
216		equals: function (o) {
217		return o.is(a);
218		},
219		equals_: function (o, elementEq) {
220		return o.fold(never$1, function (b) {
221		return elementEq(a, b);
222		});
223		},
224		toArray: function () {
225		return [a];
226		},
227		toString: function () {
228		return 'some(' + a + ')';
229		}
230		};
231		return me;
232		};
233		var from = function (value) {
234		return value === null \|\| value === undefined ? NONE : some(value);
235		};

Code Duplication Length = 62-62 lines in 8 locations

public/js/tinymce/themes/inlite/theme.js 1 location

public/js/tinymce/plugins/imagetools/plugin.js 1 location

public/js/tinymce/plugins/lists/plugin.js 1 location

public/js/tinymce/themes/modern/theme.js 1 location

public/js/tinymce/themes/mobile/theme.js 1 location

public/js/tinymce/plugins/visualchars/plugin.js 1 location

public/js/tinymce/plugins/help/plugin.js 1 location

public/js/tinymce/plugins/textpattern/plugin.js 1 location

		@@ 134-195 (lines=62) @@
131		Object.freeze(me);
132		return me;
133		}();
134		var some = function (a) {
135		var constant_a = function () {
136		return a;
137		};
138		var self = function () {
139		return me;
140		};
141		var map = function (f) {
142		return some(f(a));
143		};
144		var bind = function (f) {
145		return f(a);
146		};
147		var me = {
148		fold: function (n, s) {
149		return s(a);
150		},
151		is: function (v) {
152		return a === v;
153		},
154		isSome: always$1,
155		isNone: never$1,
156		getOr: constant_a,
157		getOrThunk: constant_a,
158		getOrDie: constant_a,
159		getOrNull: constant_a,
160		getOrUndefined: constant_a,
161		or: self,
162		orThunk: self,
163		map: map,
164		ap: function (optfab) {
165		return optfab.fold(none, function (fab) {
166		return some(fab(a));
167		});
168		},
169		each: function (f) {
170		f(a);
171		},
172		bind: bind,
173		flatten: constant_a,
174		exists: bind,
175		forall: bind,
176		filter: function (f) {
177		return f(a) ? me : NONE;
178		},
179		equals: function (o) {
180		return o.is(a);
181		},
182		equals_: function (o, elementEq) {
183		return o.fold(never$1, function (b) {
184		return elementEq(a, b);
185		});
186		},
187		toArray: function () {
188		return [a];
189		},
190		toString: function () {
191		return 'some(' + a + ')';
192		}
193		};
194		return me;
195		};
196		var from = function (value) {
197		return value === null \|\| value === undefined ? NONE : some(value);
198		};

		@@ 96-157 (lines=62) @@
93		Object.freeze(me);
94		return me;
95		}();
96		var some = function (a) {
97		var constant_a = function () {
98		return a;
99		};
100		var self = function () {
101		return me;
102		};
103		var map = function (f) {
104		return some(f(a));
105		};
106		var bind = function (f) {
107		return f(a);
108		};
109		var me = {
110		fold: function (n, s) {
111		return s(a);
112		},
113		is: function (v) {
114		return a === v;
115		},
116		isSome: always$1,
117		isNone: never$1,
118		getOr: constant_a,
119		getOrThunk: constant_a,
120		getOrDie: constant_a,
121		getOrNull: constant_a,
122		getOrUndefined: constant_a,
123		or: self,
124		orThunk: self,
125		map: map,
126		ap: function (optfab) {
127		return optfab.fold(none, function (fab) {
128		return some(fab(a));
129		});
130		},
131		each: function (f) {
132		f(a);
133		},
134		bind: bind,
135		flatten: constant_a,
136		exists: bind,
137		forall: bind,
138		filter: function (f) {
139		return f(a) ? me : NONE;
140		},
141		equals: function (o) {
142		return o.is(a);
143		},
144		equals_: function (o, elementEq) {
145		return o.fold(never$1, function (b) {
146		return elementEq(a, b);
147		});
148		},
149		toArray: function () {
150		return [a];
151		},
152		toString: function () {
153		return 'some(' + a + ')';
154		}
155		};
156		return me;
157		};
158		var from = function (value) {
159		return value === null \|\| value === undefined ? NONE : some(value);
160		};

		@@ 91-152 (lines=62) @@
88		Object.freeze(me);
89		return me;
90		}();
91		var some = function (a) {
92		var constant_a = function () {
93		return a;
94		};
95		var self = function () {
96		return me;
97		};
98		var map = function (f) {
99		return some(f(a));
100		};
101		var bind = function (f) {
102		return f(a);
103		};
104		var me = {
105		fold: function (n, s) {
106		return s(a);
107		},
108		is: function (v) {
109		return a === v;
110		},
111		isSome: always$1,
112		isNone: never$1,
113		getOr: constant_a,
114		getOrThunk: constant_a,
115		getOrDie: constant_a,
116		getOrNull: constant_a,
117		getOrUndefined: constant_a,
118		or: self,
119		orThunk: self,
120		map: map,
121		ap: function (optfab) {
122		return optfab.fold(none, function (fab) {
123		return some(fab(a));
124		});
125		},
126		each: function (f) {
127		f(a);
128		},
129		bind: bind,
130		flatten: constant_a,
131		exists: bind,
132		forall: bind,
133		filter: function (f) {
134		return f(a) ? me : NONE;
135		},
136		equals: function (o) {
137		return o.is(a);
138		},
139		equals_: function (o, elementEq) {
140		return o.fold(never$1, function (b) {
141		return elementEq(a, b);
142		});
143		},
144		toArray: function () {
145		return [a];
146		},
147		toString: function () {
148		return 'some(' + a + ')';
149		}
150		};
151		return me;
152		};
153		var from = function (value) {
154		return value === null \|\| value === undefined ? NONE : some(value);
155		};

butcherman / Tech_Bench

Code Duplication Length = 62-62 lines in 8 locations

public/js/tinymce/themes/inlite/theme.js 1 location

public/js/tinymce/plugins/imagetools/plugin.js 1 location

public/js/tinymce/plugins/lists/plugin.js 1 location

public/js/tinymce/themes/modern/theme.js 1 location

public/js/tinymce/themes/mobile/theme.js 1 location

public/js/tinymce/plugins/visualchars/plugin.js 1 location

public/js/tinymce/plugins/help/plugin.js 1 location

public/js/tinymce/plugins/textpattern/plugin.js 1 location