@machinemetrics/io-adapter-lib 2.32.0

package/test/repro/lockout-count-repro.test.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro engine counter lockout example', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/lockout-count-repro.yml');
+  });
+
+  it('completes successfully', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    source.sendValue('AIN0', 0, 0);
+    source.sendValue('AIN1', 0, 0);
+
+    source.sendValue('AIN0', 8, 1);
+    source.sendValue('AIN1', 0, 1);
+    source.sendValue('AIN0', 0, 1);
+
+    source.sendValue('AIN0', 8, 2);
+    source.sendValue('AIN1', 0, 2);
+    source.sendValue('AIN0', 0, 2);
+
+    source.sendValue('AIN0', 8, 3);
+    source.sendValue('AIN1', 8, 3);
+    source.sendValue('AIN0', 0, 3);
+    source.sendValue('AIN1', 0, 3);
+
+    source.sendValue('AIN0', 8, 4);
+    source.sendValue('AIN1', 8, 4);
+    source.sendValue('AIN0', 0, 4);
+    source.sendValue('AIN1', 0, 4);
+
+    source.sendValue('AIN0', 8, 5);
+    source.sendValue('AIN1', 8, 5);
+    source.sendValue('AIN0', 0, 5);
+    source.sendValue('AIN1', 0, 5);
+
+    source.sendValue('AIN0', 0, 6);
+    source.sendValue('AIN1', 8, 6);
+    source.sendValue('AIN1', 0, 6);
+
+    source.sendValue('AIN0', 0, 7);
+    source.sendValue('AIN1', 8, 7);
+    source.sendValue('AIN1', 0, 7);
+
+    source.sendValue('AIN0', 0, 8);
+    source.sendValue('AIN1', 0, 8);
+
+    source.sendValue('AIN0', 0, 70);
+    source.sendValue('AIN1', 8, 70);
+    source.sendValue('AIN1', 0, 70);
+
+    source.sendValue('AIN0', 8, 71);
+    source.sendValue('AIN1', 8, 71);
+    source.sendValue('AIN0', 0, 71);
+    source.sendValue('AIN1', 0, 71);
+
+    source.sendValue('AIN0', 8, 72);
+    source.sendValue('AIN0', 0, 72);
+    source.sendValue('AIN1', 0, 72);
+
+    // engine.printEngineUpdates();
+
+    engine.validateEngine('part-count', [
+      [0, 0],
+      [1, 1],
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [5, 5],
+      [6, 70],
+      [7, 71],
+    ]);
+  });
+});

package/test/repro/program-extract-repro.test.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro extract program names', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/program-extract-repro.yml');
+  });
+
+  const replayStream = (source) => {
+    source.sendValue('part_variant', '45', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue(
+      'program_comment',
+      'O4745\n(AS475045B326M.BW1)\n(DNCIDAS475045B326M.BW1) \n(ALPHATEC*15005-04-075-XXX-SHANK)\n(VER.1)\n(MAIN*SPINDLE)\n',
+      normalizeTime('2020-08-25T17:48:02.594+00:00')
+    );
+  };
+
+  it('emits extracted program name', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream(source);
+
+    engine.validateEngine('part_name', [
+      ['15005-04-075-045', normalizeTime('2020-08-25T17:48:02.594+00:00')],
+    ]);
+  });
+});
+
+function normalizeTime(time) {
+  return Date.parse(time) / 1000.0;
+}

package/test/repro/state-latch-repro.test.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro creating a state latch', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/state-latch-repro.yml');
+  });
+
+  it('completes successfully', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    source.sendValue('AIN0', 0, 0);
+    source.sendValue('AIN1', 0, 0);
+    source.sendValue('AIN2', 0, 0);
+    source.sendValue('AIN3', 0, 0);
+
+    source.sendValue('AIN0', 8, 1);
+    source.sendValue('AIN1', 0, 1);
+    source.sendValue('AIN0', 0, 1);
+
+    source.sendValue('AIN0', 8, 2);
+    source.sendValue('AIN1', 0, 2);
+    source.sendValue('AIN0', 0, 2);
+
+    source.sendValue('AIN0', 8, 3);
+    source.sendValue('AIN1', 8, 3);
+    source.sendValue('AIN0', 0, 3);
+    source.sendValue('AIN1', 0, 3);
+
+    source.sendValue('AIN0', 0, 20);
+    source.sendValue('AIN1', 8, 20);
+    source.sendValue('AIN1', 0, 20);
+
+    source.sendValue('AIN0', 8, 21);
+    source.sendValue('AIN1', 8, 21);
+    source.sendValue('AIN0', 0, 21);
+    source.sendValue('AIN1', 0, 21);
+
+    source.sendValue('AIN0', 8, 22);
+    source.sendValue('AIN1', 0, 22);
+    source.sendValue('AIN0', 0, 22);
+
+    // engine.printEngineUpdates();
+
+    engine.validateEngine('part-count', [
+      [0, 0.1],
+      [1, 1],
+      [2, 2],
+      [3, 3],
+      [4, 20],
+      [5, 21],
+    ]);
+  });
+});

package/test/repro/ternary-repro.test.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro ternary not triggering', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/ternary-repro.yml');
+  });
+
+  const replayStream = (source) => {
+    source.sendValue('program_comment', 'O1012 \n\n(PART 10464)\n(REV C) \n(SR-32J)\n(04-16-2019)\n', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+  };
+
+  // Tests that a value is returned from the ternary expression with the options are named variables.
+  // Previously they were not matched due to being adjacent to a colon
+  it('emits result of ternary operation', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream(source);
+
+    engine.validateEngine('parsed_program1', [
+      ['', normalizeTime('2020-08-25T17:48:02.594+00:00')],
+    ]);
+    engine.validateEngine('parsed_program2', [
+      ['PART 10464', normalizeTime('2020-08-25T17:48:02.594+00:00')],
+    ]);
+    engine.validateEngine('parsed_program', [
+      ['PART 10464', normalizeTime('2020-08-25T17:48:02.594+00:00')],
+    ]);
+  });
+});
+
+function normalizeTime(time) {
+  return Date.parse(time) / 1000.0;
+}

package/test/transform/accumulte.test.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const Accumulate = require('../../lib/transform').accumulate;
+const testUtils = require('../util/testUtils');
+
+describe('accumulate transform tests', function () {
+  it('accumulate irregular digital', function () {
+    const filter = new Accumulate(testUtils.standardBuilderArgs(null, 'test1'));
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1, 2], [1, 4], [2, 6], [4, 10], [0, 14], [9, 15], [10, 16], [11, 21],
+    ]);
+    filter.validate([
+      [1, 2], [2, 4], [4, 6], [8, 10], [8, 14], [17, 15], [27, 16], [38, 21],
+    ]);
+  });
+});

package/test/transform/average.test.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const Average = require('../../lib/transform').average;
+const testUtils = require('../util/testUtils');
+
+describe('average transform tests', function () {
+  it('average regular 1', function () {
+    const filter = new Average(1);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+  });
+
+  it('average regular 2', function () {
+    const filter = new Average(2);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([0.5, 2, 4, 6, 8, 5.5, 3, 5, 7, 4], 1);
+  });
+});

package/test/transform/debounce.test.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const Debounce = require('../../lib/transform').debounce;
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('debounce transform tests', function () {
+  it('debounce regular 1', function () {
+    const filter = new Debounce(1);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('^_^_^^^_^^^_^___^___^_^_^^^^', 1);
+    filter.valdDigital('_____^^^^^^^^^___________^^^', 1, false);
+  });
+
+  it('debounce regular 2', function () {
+    const filter = new Debounce(2);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('^_^_^^^_^^^_^___^___^_^_^^^^__^^^', 1);
+    filter.valdDigital('______^^^^^^^^^___________^^^^^^^', 1, false);
+  });
+
+  it('debounce irregular', function () {
+    const filter = new Debounce(1);
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 1], [false, 2], [true, 3], [false, 4], [true, 5], [false, 8], [true, 9], [false, 12], [true, 13],
+      [false, 14], [true, 17], [false, 18], [true, 21], [false, 22], [true, 23], [false, 24], [true, 25],
+    ]);
+    filter.validate([
+      [false, 1], [false, 2], [false, 3], [false, 4], [false, 5],
+      [true, 6], [true, 8], [true, 9], [true, 12], [true, 13],
+      [true, 14], [false, 15], [false, 17], [false, 18], [false, 21],
+      [false, 22], [false, 23], [false, 24], [false, 25],
+    ]);
+  });
+});
+
+describe('debounce transform full engine tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/debounce.yml');
+  });
+
+  it('handles engine probe', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var1, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 10], [false, 12]]);
+    source.probe(15);
+    source.probe(18);
+    source.sendValue('active', true, 18);
+    source.sendValue('active', false, 24);
+    source.sendValues('active', [[true, 26], [false, 28], [true, 30]]);
+
+    engine.validateFilter([
+      [false, 0], [false, 2], [false, 4], [false, 10], [false, 12],
+      [false, 18],
+      [true, 23], [true, 24],
+      [true, 26], [true, 28], [true, 30],
+    ]);
+  });
+});

package/test/transform/downsample.test.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Downsample = require('../../lib/transform').downsample;
+const testUtils = require('../util/testUtils');
+
+describe('downsample transform tests', function () {
+  it('downsample regular 2', function () {
+    const filter = new Downsample(2);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([3, 7, 2, 6, 0], 2);
+  });
+
+  it('downsample regular 2.25', function () {
+    const filter = new Downsample(2.25);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([3.5, 8, 3.5, 8], 2.25);
+  });
+
+  it('downsample regular 3', function () {
+    const filter = new Downsample(3);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([5, 2, 8], 3);
+  });
+});

package/test/transform/edge.test.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const Edge = require('../../lib/transform').edge;
+const testUtils = require('../util/testUtils');
+
+describe('edge transform tests', function () {
+  it('edge regular', function () {
+    const filter = new Edge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('__|_|_|___|___|||____|', 1);
+  });
+
+  it('edge irregular', function () {
+    const filter = new Edge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 2], [false, 4], [true, 6], [false, 10], [true, 14], [false, 15], [true, 16], [false, 21],
+    ]);
+    filter.validate([
+      [true, 2], [false, 2], [true, 4], [false, 4], [true, 6], [false, 6], [true, 10], [false, 10],
+      [true, 14], [false, 14], [true, 15], [false, 15], [true, 16], [false, 16], [true, 21], [false, 21],
+    ]);
+  });
+});

package/test/transform/expression.test.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const _ = require('lodash');
+const { expect } = require('chai');
+const EventEmitter = require('eventemitter3');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const Expression = require('../../lib/transform').expression;
+const EngineV2 = require('../../lib/engine/engineV2');
+const testUtils = require('../util/testUtils');
+const math = require('../../lib/math');
+
+describe('expression transform tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/expression.yml');
+  });
+
+  it('expression regular 1', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    const filter = new Expression({
+      engine,
+      path: 'variables.var1.1.expression',
+      args: { compiledExpression: math.compile('this + 5') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([6, 8, 10, 12, 14, 7, 9, 11, 13, 5], 1);
+  });
+
+  it('expression regular 2', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    source.sendValue('counter', 0, 0);
+
+    const filter = new Expression({
+      engine,
+      path: 'variables.var2.1.expression',
+      args: { compiledExpression: math.compile('this > 5 ? 0 : this + counter') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1, 0, {
+      itemPreProcess: (value, time) => { engine.getState('counter').value = time; },
+    });
+    filter.valdAnalog([1, 4, 7, 0, 0, 7, 10, 0, 0, 9], 1);
+  });
+
+  // NB: An expression filter can accept and emit any type, and is not type-checkable.
+  it('expression irregular', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    source.sendValue('counter', 0, 0);
+
+    const filter = new Expression({
+      engine,
+      path: 'variables.var3.1.expression',
+      args: { compiledExpression: math.compile('counter + 10') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 1], [false, 2], [true, 5], [false, 8], [true, 10], [false, 11], [true, 12], [false, 15], [true, 18],
+    ], {
+      itemPreProcess: (value, time) => { engine.getState('counter').value = time; },
+    });
+    filter.validate([
+      [11, 1], [12, 2], [15, 5], [18, 8], [20, 10], [21, 11], [22, 12], [25, 15], [28, 18],
+    ]);
+  });
+
+  it('expression arrays', function () {
+    const engine = new EngineV2(config);
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    source.sendValue('counter', [0, 0], 0);
+
+    const filter = new Expression({
+      engine,
+      path: 'variables.var3.1.expression',
+      args: { compiledExpression: math.compile('sum(this)') },
+    });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [[1, 3], 1], [[4, 6], 2], [[8, 4], 5], [[10, 10], 8], [[10, 11], 10], [[13, 15], 11], [[15, 15], 12],
+      [[16, 17], 15], [[20, 25], 18],
+    ]);
+    filter.validate([
+      [4, 1], [10, 2], [12, 5], [20, 8], [21, 10], [28, 11], [30, 12], [33, 15], [45, 18],
+    ]);
+  });
+
+  it('expression as source', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var4, source);
+
+    source.sendValues('xact', [[1, 0], [3, 1], [5, 2], [7, 3], [9, 4], [2, 5], [4, 6], [6, 7], [8, 8], [0, 9]]);
+    engine.validateFilter([[6, 0], [8, 1], [10, 2], [12, 3], [14, 4], [7, 5], [9, 6], [11, 7], [13, 8], [5, 9]]);
+  });
+
+  // Expression will silently swallow the eval error and not emit updates
+  it('expression as source cant use this', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var5, source);
+
+    source.sendValues('xact', [[1, 0], [3, 1], [5, 2], [7, 3], [9, 4], [2, 5], [4, 6], [6, 7], [8, 8], [0, 9]]);
+    expect(engine.variablePool.var5.lastSampleTime).to.eq(9);
+    expect(engine.variablePool.var5.lastSuppliedValue).to.eq(0);
+    expect(engine.variablePool.var5.available).to.eq(false);
+    engine.validateFilter([]);
+  });
+
+  it('expression object key', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var6, source);
+
+    const fill = (n) => {
+      return _.times(n).map(i => {
+        return [{ foo: i * 2 }, i];
+      });
+    };
+
+    source.sendValues('data1', fill(8));
+    engine.validateFilter([[5, 0], [7, 1], [9, 2], [11, 3], [13, 4], [15, 5], [17, 6], [19, 7]]);
+  });
+
+  it('expression object sub-key', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var7, source);
+
+    const fill = (n) => {
+      return _.times(n).map(i => {
+        return [{ foo: { bar: i * 2 }, baz: 'xyz' }, i];
+      });
+    };
+
+    source.sendValues('data2', fill(8));
+    engine.validateFilter([[5, 0], [7, 1], [9, 2], [11, 3], [13, 4], [15, 5], [17, 6], [19, 7]]);
+  });
+
+  it('expression object sub-key separated', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var8, source);
+
+    const fill = (n) => {
+      return _.times(n).map(i => {
+        return [{ foo: { bar: i * 2 }, baz: 'xyz' }, i];
+      });
+    };
+
+    source.sendValues('data3', fill(8));
+    engine.validateFilter([[5, 0], [7, 1], [9, 2], [11, 3], [13, 4], [15, 5], [17, 6], [19, 7]]);
+  });
+});
+
+class ValueSource extends EventEmitter {
+  sendValue(name, value, time) {
+    this.emit('update', name, value, time);
+  }
+}

package/test/transform/fallingEdge.test.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const FallingEdge = require('../../lib/transform').fallingEdge;
+const testUtils = require('../util/testUtils');
+
+describe('falling-edge transform tests', function () {
+  it('falling-edge regular', function () {
+    const filter = new FallingEdge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('____|_____|____|_____|', 1);
+  });
+
+  it('falling-edge regular high start', function () {
+    const filter = new FallingEdge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('^^^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('____|_____|____|_____|', 1);
+  });
+
+  it('falling-edge irregular', function () {
+    const filter = new FallingEdge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 2], [false, 4], [true, 6], [false, 10], [true, 14], [false, 15], [true, 16], [false, 21],
+    ]);
+    filter.validate([
+      [false, 2], [true, 4], [false, 4], [false, 6], [true, 10], [false, 10], [false, 14], [true, 15],
+      [false, 15], [false, 16], [true, 21], [false, 21],
+    ]);
+  });
+
+  it('falling-edge regular min-dwell 3', function () {
+    const filter = new FallingEdge({ minDwell: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^___^^^_', 1);
+    filter.valdDigital('__________|__________|_____|', 1);
+  });
+
+  it('falling-edge regular max-dwell 3', function () {
+    const filter = new FallingEdge({ maxDwell: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^___^^^_', 1);
+    filter.valdDigital('____|__________|___________|', 1);
+  });
+
+  it('falling-edge regular dwell 2 3', function () {
+    const filter = new FallingEdge({ minDwell: 2, maxDwell: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^___^^^_', 1);
+    filter.valdDigital('____|______________________|', 1);
+  });
+});