aurelia/aurelia

File instruction-parser.spec.ts has 280 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import { IRouter, RouterConfiguration, RoutingInstruction } from '@aurelia/router';
import { CustomElement, Aurelia } from '@aurelia/runtime-html';
import { assert, MockBrowserHistoryLocation, TestContext } from '@aurelia/testing';

describe('router/instruction-parser.spec.ts', function () {

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a/b/c/d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '((a/b)/c)/d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a/((b/c)/d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a/(b/c))/d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a/b)/c/d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a/b/(c/d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a/b/c)/d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a/(b/(c/d))', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a/b)/(c/d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a/(b/c)/d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a/(b/c/d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }] }], clean: 'a/b/c/d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: '(a+b/c)/d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: 'a+(b/c/d)', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: 'a+((b/c)/d)', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: '(a+(b/c))/d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: 'a+(b/c)/d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: 'a+b/c/d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a/b/c)+d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }, { "component": "d" }], clean: 'a/b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a/(b/c))+d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }, { "component": "d" }], clean: 'a/b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a/(b/c)+d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }, { "component": "d" }], clean: 'a/b/c+d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: 'a+b/(c/d)', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 8 locations. Consider refactoring.

Open

      { instruction: 'a+(b/(c/d))', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a+b/c/d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a/b/c+d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }, { "component": "d" }], clean: 'a/b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '((a/b)/c)+d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }, { "component": "d" }], clean: 'a/b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a/b)/c+d', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }, { "component": "d" }], clean: 'a/b/c+d' },

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

      { instruction: '(a/b)+c/d', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a/b+c/d' },

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

      { instruction: 'a/b+c/d', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a/b+c/d' },

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

      { instruction: '(a/b)+(c/d)', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a/b+c/d' },

• Read up
  Read up

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

Open

      { instruction: '(a/b)/(c+d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }, { "component": "d" }] }] }], clean: 'a/b/(c+d)' },

• Read up
  Read up

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

Open

      { instruction: 'a/(b/(c+d))', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }, { "component": "d" }] }] }], clean: 'a/b/(c+d)' },

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

      { instruction: 'a/b+(c/d)', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a/b+c/d' },

• Read up
  Read up

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

Open

      { instruction: 'a/(b+c/d)', parsed: [{ "component": "a", "children": [{ "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a/(b+c/d)' },

• Read up
  Read up

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

Open

      { instruction: 'a/b/(c+d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }, { "component": "d" }] }] }], clean: 'a/b/(c+d)' },

• Read up
  Read up

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

Open

      { instruction: 'a/(b/c+d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }] }], clean: 'a/(b/c+d)' },

• Read up
  Read up

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

Open

      { instruction: 'a/(b+(c/d))', parsed: [{ "component": "a", "children": [{ "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }] }], clean: 'a/(b+c/d)' },

• Read up
  Read up

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

Open

      { instruction: 'a/((b/c)+d)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }] }], clean: 'a/(b/c+d)' },

• Read up
  Read up

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

Open

        case 'error:children':
          errMsg = 'Error: Instruction parser error: Children below scope';
          assert.equal(error.toString().slice(0, errMsg.length), errMsg, `error:scopes:${msg}`);
          break;

• Read up
  Read up

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

Open

        case 'error:siblings':
          errMsg = 'Error: Instruction parser error: Unnecessary siblings separator';
          assert.equal(error.toString().slice(0, errMsg.length), errMsg, `error:siblings:${msg}`);
          break;

• Read up
  Read up

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

Open

        case 'error:scopes':
          errMsg = 'Error: Instruction parser error: Unnecessary scopes';
          assert.equal(error.toString().slice(0, errMsg.length), errMsg, `error:scopes:${msg}`);
          break;

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a/b+c+d', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c" }, { "component": "d" }], clean: 'a/b+c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '((a/b)+c)+d', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c" }, { "component": "d" }], clean: 'a/b+c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a/b)+(c+d)', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c" }, { "component": "d" }], clean: 'a/b+c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+(b/c)+d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }], clean: 'a+b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+(b+c/d)', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a+b+c/d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a/b)+c+d', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c" }, { "component": "d" }], clean: 'a/b+c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+(b+(c/d))', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a+b+c/d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+b+(c/d)', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a+b+c/d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+b/c+d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }], clean: 'a+b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a+b)+(c/d)', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a+b+c/d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+(b/c+d)', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }], clean: 'a+b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a+b)+c/d', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a+b+c/d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a/b+(c+d)', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c" }, { "component": "d" }], clean: 'a/b+c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a/b+c)+d', parsed: [{ "component": "a", "children": [{ "component": "b" }] }, { "component": "c" }, { "component": "d" }], clean: 'a/b+c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a+(b/c))+d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }], clean: 'a+b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: '(a+b/c)+d', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }], clean: 'a+b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+((b/c)+d)', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }] }, { "component": "d" }], clean: 'a+b/c+d' },

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

      { instruction: 'a+b+c/d', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c", "children": [{ "component": "d" }] }], clean: 'a+b+c/d' },

• Read up
  Read up

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

Open

      { instruction: 'a/(b+c+d)', parsed: [{ "component": "a", "children": [{ "component": "b" }, { "component": "c" }, { "component": "d" }] }], clean: 'a/(b+c+d)' },

• Read up
  Read up

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

Open

      { instruction: 'a/(b+(c+d))', parsed: [{ "component": "a", "children": [{ "component": "b" }, { "component": "c" }, { "component": "d" }] }], clean: 'a/(b+c+d)' },

• Read up
  Read up

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

Open

      { instruction: 'a+b/(c+d)', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }, { "component": "d" }] }], clean: 'a+b/(c+d)' },

• Read up
  Read up

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

Open

      { instruction: '(a/(b+c))+d', parsed: [{ "component": "a", "children": [{ "component": "b" }, { "component": "c" }] }, { "component": "d" }], clean: 'a/(b+c)+d' },

• Read up
  Read up

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

Open

      { instruction: 'a/(b+c)+d', parsed: [{ "component": "a", "children": [{ "component": "b" }, { "component": "c" }] }, { "component": "d" }], clean: 'a/(b+c)+d' },

• Read up
  Read up

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

Open

      { instruction: 'a+(b/(c+d))', parsed: [{ "component": "a" }, { "component": "b", "children": [{ "component": "c" }, { "component": "d" }] }], clean: 'a+b/(c+d)' },

• Read up
  Read up

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

Open

      { instruction: 'a/((b+c)+d)', parsed: [{ "component": "a", "children": [{ "component": "b" }, { "component": "c" }, { "component": "d" }] }], clean: 'a/(b+c+d)' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: 'b/c/d', parsed: [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'b/c/d' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '((b/c)/d)', parsed: [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'b/c/d' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '(a/(b/c))', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'a/b/c' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '((a/b)/c)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'a/b/c' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '(b/c)/d', parsed: [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'b/c/d' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '+a/b/c', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'error:siblings' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: 'b/(c/d)', parsed: [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'b/c/d' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: 'a/b/c', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'a/b/c' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '(a/b/c)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'a/b/c' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '(b/c/d)', parsed: [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'b/c/d' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: 'a/(b/c)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'a/b/c' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '+a/(b/c)', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'error:siblings' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '+(a/b)/c', parsed: [{ "component": "a", "children": [{ "component": "b", "children": [{ "component": "c" }] }] }], clean: 'error:siblings' },

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

      { instruction: '(b/(c/d))', parsed: [{ "component": "b", "children": [{ "component": "c", "children": [{ "component": "d" }] }] }], clean: 'b/c/d' },

• Read up
  Read up

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

Open

    const au = ctx.wnd['au'] = new Aurelia(container)
      .register(RouterConfiguration)
      .app({ host: host, component: App });

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    async function tearDown() {
      await au.stop(true);
      ctx.doc.body.removeChild(host);

      au.dispose();

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a+(b+c+d)', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a+((b+c)+d)', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a+b+c+d', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a+(b+c))+d', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a+b+c)+d', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '((a+b)+c)+d', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a+b)+c+d', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: '(a+b)+(c+d)', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },

• Read up
  Read up

Similar blocks of code found in 11 locations. Consider refactoring.

Open

      { instruction: 'a+(b+(c+d))', parsed: [{ "component": "a" }, { "component": "b" }, { "component": "c" }, { "component": "d" }], clean: 'a+b+c+d' },