"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
const spec_1 = require("../../../spec/reducers/spec");
const spec_2 = require("../../../spec/util/spec");
const _ids_1 = require("../../../system/_ids");
assert.deepEqual({
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {
        dfgte: {
            name: 'foo',
            plug: { '0': { unitId: 'identity', pinId: 'tfgre' } },
        },
    },
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}, (0, spec_1.exposeInputSet)({
    pinId: 'dfgte',
    input: {
        name: 'foo',
        plug: { '0': { unitId: 'identity', pinId: 'tfgre' } },
    },
}, {
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {},
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}));
assert.deepEqual({
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {},
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}, (0, spec_1.coverInputSet)({ pinId: 'frtdk' }, {
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {
        frtdk: {
            plug: { 0: { pinId: 'bar', unitId: 'identity' } },
            name: 'foo',
        },
    },
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}));
assert.deepEqual({
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {
        asdrw: { plug: { 0: { pinId: 'foo', unitId: 'identity' } }, name: 'zaz' },
    },
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}, (0, spec_1.setPinSetName)({ type: 'input', id: 'asdrw', name: 'zaz' }, {
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {
        asdrw: {
            plug: { 0: { pinId: 'foo', unitId: 'identity' } },
            name: 'bar',
        },
    },
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}));
assert.deepEqual({
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {},
    outputs: {
        llkfd: { plug: { 0: { unitId: 'identity', pinId: 'bar' } }, name: 'foo' },
    },
    metadata: {
        icon: null,
        description: '',
    },
}, (0, spec_1.exposeOutputSet)({
    pinId: 'llkfd',
    output: {
        plug: { 0: { unitId: 'identity', pinId: 'bar' } },
        name: 'foo',
    },
}, {
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {},
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}));
assert.deepEqual({
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {},
    outputs: {},
    metadata: {
        icon: null,
        description: '',
    },
}, (0, spec_1.coverOutputSet)({ pinId: 'oriur' }, {
    name: '?',
    units: {
        identity: {
            id: _ids_1.ID_IDENTITY,
        },
    },
    merges: {},
    inputs: {},
    outputs: {
        oriur: {
            plug: { 0: { pinId: 'oriur', unitId: 'identity' } },
            name: 'foo',
        },
    },
    metadata: {
        icon: null,
        description: '',
    },
}));
assert.deepEqual({
    name: '?',
    units: {},
    merges: {},
    inputs: {},
    outputs: {
        gghdb: {
            plug: { 0: { pinId: 'foo', unitId: '0' } },
            name: 'zaz',
            functional: true,
        },
    },
    metadata: {
        icon: null,
        description: '',
    },
}, (0, spec_1.setPinSetFunctional)({ type: 'output', pinId: 'gghdb', functional: true }, {
    name: '?',
    units: {},
    merges: {},
    inputs: {},
    outputs: {
        gghdb: {
            plug: { 0: { pinId: 'foo', unitId: '0' } },
            name: 'zaz',
        },
    },
    metadata: {
        icon: null,
        description: '',
    },
}));
assert.equal((0, spec_2.getMergePinCount)({
    if0: { input: { a: true }, output: { b: true } },
    if1: { input: { a: true } },
}), 3);
assert.equal((0, spec_2.getMergePinCount)({
    if0: { input: { a: true } },
}), 1);
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { unitId: 'if0', pinId: 'b' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.removeUnit)({ unitId: 'not' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}));
// setUnitMetadata
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If', metadata: { rename: 'if true' } },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: { not: { output: { '!a': true } }, if1: { input: { b: true } } },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: 'branch', description: '' },
}, (0, spec_1.setUnitMetadata)({ id: 'if0', path: ['rename'], value: 'if true' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: 'branch', description: '' },
}), 'setUnitMetadata');
// setMetadata
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: { not: { output: { '!a': true } }, if1: { input: { b: true } } },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: 'branch', description: '' },
}, (0, spec_1.setMetadata)({ path: ['metadata', 'icon'], value: 'branch' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '' },
}), 'setMetadata');
// setUnitPinData
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If', input: { a: { data: 1 } } },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: { not: { output: { '!a': true } }, if1: { input: { b: true } } },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.setUnitPinData)({ unitId: 'if0', type: 'input', pinId: 'a', data: 1 }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'setUnitPinData');
// removeUnitPinData
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If', input: { a: {} } },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: { not: { output: { '!a': true } }, if1: { input: { b: true } } },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.removeUnitPinData)({ unitId: 'if0', type: 'input', pinId: 'a' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If', input: { a: { data: '1' } } },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'removeUnitPinData');
// setUnitInputConstant
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If', input: { a: { constant: true } } },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: { not: { output: { '!a': true } }, if1: { input: { b: true } } },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.setUnitInputConstant)({ unitId: 'if0', pinId: 'a', constant: true }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'setUnitInputConstant');
// setUnitOutputIgnored
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If', output: { a: { ignored: true } } },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: { not: { output: { '!a': true } }, if1: { input: { b: true } } },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.setUnitOutputIgnored)({ unitId: 'if0', pinId: 'a', ignored: true }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'setUnitOutputIgnored');
// addMerge
assert.deepEqual({
    name: 'if a ≤ b',
    units: {
        lessthanequal: { id: 'system/f/comparisson/LessThanEqual' },
        greaterthan: { id: 'system/f/comparisson/GreaterThan' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
    },
    merges: {
        ttcas: {
            lessthanequal: { input: { b: true } },
            greaterthan: { input: { b: true } },
        },
        uzzat: {
            lessthanequal: { input: { a: true } },
            greaterthan: { input: { a: true } },
        },
    },
    inputs: {
        a: {
            name: 'a',
            plug: { 0: { mergeId: 'uzzat' } },
        },
    },
    outputs: {},
    metadata: { icon: null, description: '...' },
}, (0, spec_1.addMerge)({
    mergeId: 'uzzat',
    merge: {
        lessthanequal: { input: { a: true } },
        greaterthan: { input: { a: true } },
    },
}, {
    name: 'if a ≤ b',
    units: {
        lessthanequal: { id: 'system/f/comparisson/LessThanEqual' },
        greaterthan: { id: 'system/f/comparisson/GreaterThan' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
    },
    merges: {
        ttcas: {
            lessthanequal: { input: { b: true } },
            greaterthan: { input: { b: true } },
        },
    },
    inputs: {
        a: {
            name: 'a',
            plug: {
                0: {
                    unitId: 'lessthanequal',
                    pinId: 'a',
                },
            },
        },
    },
    outputs: {},
    metadata: { icon: null, description: '...' },
}), 'addMerge');
// addMerges
assert.deepEqual({
    name: 'if else a ≤ b',
    units: {
        lessthanequal: { id: 'system/f/comparisson/LessThanEqual' },
        greaterthan: { id: 'system/f/comparisson/GreaterThan' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
    },
    merges: {
        myikn: {
            greaterthan: { input: { b: true } },
            lessthanequal: { input: { b: true } },
        },
        vuhxu: {
            greaterthan: { input: { a: true } },
            lessthanequal: { input: { a: true } },
            if1: { input: { a: true } },
            if0: { input: { a: true } },
        },
        snnit: {
            greaterthan: { output: { 'a > b': true } },
            if0: { input: { b: true } },
        },
        wahsl: {
            lessthanequal: { output: { 'a ≤ b': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        smtzy: { name: 'a', plug: { 0: { mergeId: 'vuhxu' } } },
        ajuwn: { name: 'b', plug: { 0: { mergeId: 'myikn' } } },
    },
    outputs: {
        gmmch: {
            name: 'a ≤ b ? a',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
        rewmg: {
            name: 'a > b ? a',
            plug: { 0: { unitId: 'if0', pinId: 'aifb' } },
        },
    },
    metadata: {
        icon: 'filter',
        description: 'forward `a` depending on `a ≤ b`',
    },
}, (0, spec_1.addMerges)({
    merges: {
        vuhxu: {
            if0: { input: { a: true } },
        },
        snnit: {
            greaterthan: { output: { 'a > b': true } },
            if0: { input: { b: true } },
        },
    },
}, {
    name: 'if else a ≤ b',
    units: {
        lessthanequal: { id: 'system/f/comparisson/LessThanEqual' },
        greaterthan: { id: 'system/f/comparisson/GreaterThan' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
    },
    merges: {
        myikn: {
            greaterthan: { input: { b: true } },
            lessthanequal: { input: { b: true } },
        },
        vuhxu: {
            greaterthan: { input: { a: true } },
            lessthanequal: { input: { a: true } },
            if1: { input: { a: true } },
        },
        wahsl: {
            lessthanequal: { output: { 'a ≤ b': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        smtzy: { name: 'a', plug: { 0: { mergeId: 'vuhxu' } } },
        ajuwn: { name: 'b', plug: { 0: { mergeId: 'myikn' } } },
    },
    outputs: {
        gmmch: {
            name: 'a ≤ b ? a',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
        rewmg: {
            name: 'a > b ? a',
            plug: { 0: { unitId: 'if0', pinId: 'aifb' } },
        },
    },
    metadata: {
        icon: 'filter',
        description: 'forward `a` depending on `a ≤ b`',
    },
}), 'addMerges');
// removePinFromMerge
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.removePinFromMerge)({ id: 'merge0', unitId: 'if0', type: 'input', pinId: 'a' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'removePinFromMerge');
// removePinFromMerge
assert.deepEqual({
    name: 'range',
    units: {
        lte: { id: 'system/f/comparisson/LessThan' },
        increment: { id: 'core/common/Increment' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        id0: { id: 'system/f/control/Identity' },
    },
    merges: {
        merge0: {
            increment: { output: { 'a + 1': true } },
            lte: { input: { a: true } },
        },
        merge1: {
            if0: { output: { aifb: true } },
            increment: { input: { a: true } },
        },
        merge2: {
            lte: { output: { 'a < b': true } },
            if0: { input: { b: true } },
            if1: { input: { b: true } },
        },
        merge3: {
            id0: { output: { a: true } },
            if1: { input: { a: true } },
            lte: { input: { b: true } },
        },
        merge4: {
            if1: { output: { aifb: true } },
            id0: { input: { a: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge3' } } },
    },
    outputs: { i: { name: 'i', plug: { 0: { mergeId: 'merge1' } } } },
    metadata: { icon: 'sort-numeric-down', description: '...' },
}, (0, spec_1.removePinFromMerge)({ id: 'merge0', unitId: 'if0', type: 'input', pinId: 'a' }, {
    name: 'range',
    units: {
        lte: { id: 'system/f/comparisson/LessThan' },
        increment: { id: 'core/common/Increment' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        id0: { id: 'system/f/control/Identity' },
    },
    merges: {
        merge0: {
            increment: { output: { 'a + 1': true } },
            if0: { input: { a: true } },
            lte: { input: { a: true } },
        },
        merge1: {
            if0: { output: { aifb: true } },
            increment: { input: { a: true } },
        },
        merge2: {
            lte: { output: { 'a < b': true } },
            if0: { input: { b: true } },
            if1: { input: { b: true } },
        },
        merge3: {
            id0: { output: { a: true } },
            if1: { input: { a: true } },
            lte: { input: { b: true } },
        },
        merge4: {
            if1: { output: { aifb: true } },
            id0: { input: { a: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge3' } } },
    },
    outputs: { i: { name: 'i', plug: { 0: { mergeId: 'merge1' } } } },
    metadata: { icon: 'sort-numeric-down', description: '...' },
}), 'removePinFromMerge');
// removeMerge
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: {} } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.removeMerge)({ id: 'merge0' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'removeMerge');
// removeUnitMerges
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { unitId: 'if1', pinId: 'a' } } },
        b: { name: 'b', plug: { 0: { unitId: 'not', pinId: 'a' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.removeUnitMerges)({ id: 'if0' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'removeUnitMerges');
// mergeMerges
assert.deepEqual({
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: {
            if0: { input: { a: true, b: true } },
            if1: { input: { a: true } },
            not: { input: { a: true } },
        },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}, (0, spec_1.mergeMerges)({ a: 'merge0', b: 'merge1' }, {
    name: 'if else',
    units: {
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
        not: { id: 'system/f/logic/Not' },
    },
    merges: {
        merge0: { if0: { input: { a: true } }, if1: { input: { a: true } } },
        merge1: { if0: { input: { b: true } }, not: { input: { a: true } } },
        merge2: {
            not: { output: { '!a': true } },
            if1: { input: { b: true } },
        },
    },
    inputs: {
        a: { name: 'a', plug: { 0: { mergeId: 'merge0' } } },
        b: { name: 'b', plug: { 0: { mergeId: 'merge1' } } },
    },
    outputs: {
        aifb: { name: 'aifb', plug: { 0: { unitId: 'if0', pinId: 'aifb' } } },
        'a if not b': {
            name: 'a if not b',
            plug: { 0: { unitId: 'if1', pinId: 'aifb' } },
        },
    },
    metadata: { icon: null, description: '...' },
}), 'mergeMerges');
// addPinToMerge
assert.deepEqual({
    name: 'if a ≤ b',
    units: {
        lessthanequal: { id: 'system/f/comparisson/LessThanEqual' },
        greaterthan: { id: 'system/f/comparisson/GreaterThan' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
    },
    merges: {
        ttcas: {
            lessthanequal: { input: { b: true } },
            greaterthan: { input: { b: true } },
        },
        uzzat: {
            lessthanequal: { input: { a: true } },
            greaterthan: { input: { a: true } },
            if0: { input: { a: true } },
        },
    },
    inputs: {},
    outputs: {},
    metadata: { icon: null, description: '...' },
}, (0, spec_1.addPinToMerge)({ mergeId: 'uzzat', unitId: 'if0', type: 'input', pinId: 'a' }, {
    name: 'if a ≤ b',
    units: {
        lessthanequal: { id: 'system/f/comparisson/LessThanEqual' },
        greaterthan: { id: 'system/f/comparisson/GreaterThan' },
        if0: { id: 'system/f/control/If' },
        if1: { id: 'system/f/control/If' },
    },
    merges: {
        ttcas: {
            lessthanequal: { input: { b: true } },
            greaterthan: { input: { b: true } },
        },
        uzzat: {
            lessthanequal: { input: { a: true } },
            greaterthan: { input: { a: true } },
        },
    },
    inputs: {},
    outputs: {},
    metadata: { icon: null, description: '...' },
}), 'addPinToMerge');
//# sourceMappingURL=spec.js.map