node-red-contrib-tak-registration 0.2.2 → 0.3.2

package/node_modules/deep-equal/index.js

@@ -0,0 +1,112 @@
+var objectKeys = require('object-keys');
+var isArguments = require('is-arguments');
+var is = require('object-is');
+var isRegex = require('is-regex');
+var flags = require('regexp.prototype.flags');
+var isDate = require('is-date-object');
+
+var getTime = Date.prototype.getTime;
+
+function deepEqual(actual, expected, options) {
+  var opts = options || {};
+
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (opts.strict ? is(actual, expected) : actual === expected) {
+    return true;
+  }
+
+  // 7.3. Other pairs that do not both pass typeof value == 'object', equivalence is determined by ==.
+  if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {
+    return opts.strict ? is(actual, expected) : actual == expected;
+  }
+
+  /*
+   * 7.4. For all other Object pairs, including Array objects, equivalence is
+   * determined by having the same number of owned properties (as verified
+   * with Object.prototype.hasOwnProperty.call), the same set of keys
+   * (although not necessarily the same order), equivalent values for every
+   * corresponding key, and an identical 'prototype' property. Note: this
+   * accounts for both named and indexed properties on Arrays.
+   */
+  // eslint-disable-next-line no-use-before-define
+  return objEquiv(actual, expected, opts);
+}
+
+function isUndefinedOrNull(value) {
+  return value === null || value === undefined;
+}
+
+function isBuffer(x) {
+  if (!x || typeof x !== 'object' || typeof x.length !== 'number') {
+    return false;
+  }
+  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
+    return false;
+  }
+  if (x.length > 0 && typeof x[0] !== 'number') {
+    return false;
+  }
+  return true;
+}
+
+function objEquiv(a, b, opts) {
+  /* eslint max-statements: [2, 50] */
+  var i, key;
+  if (typeof a !== typeof b) { return false; }
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) { return false; }
+
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) { return false; }
+
+  if (isArguments(a) !== isArguments(b)) { return false; }
+
+  var aIsRegex = isRegex(a);
+  var bIsRegex = isRegex(b);
+  if (aIsRegex !== bIsRegex) { return false; }
+  if (aIsRegex || bIsRegex) {
+    return a.source === b.source && flags(a) === flags(b);
+  }
+
+  if (isDate(a) && isDate(b)) {
+    return getTime.call(a) === getTime.call(b);
+  }
+
+  var aIsBuffer = isBuffer(a);
+  var bIsBuffer = isBuffer(b);
+  if (aIsBuffer !== bIsBuffer) { return false; }
+  if (aIsBuffer || bIsBuffer) { // && would work too, because both are true or both false here
+    if (a.length !== b.length) { return false; }
+    for (i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) { return false; }
+    }
+    return true;
+  }
+
+  if (typeof a !== typeof b) { return false; }
+
+  try {
+    var ka = objectKeys(a);
+    var kb = objectKeys(b);
+  } catch (e) { // happens when one is a string literal and the other isn't
+    return false;
+  }
+  // having the same number of owned properties (keys incorporates hasOwnProperty)
+  if (ka.length !== kb.length) { return false; }
+
+  // the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  // ~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i]) { return false; }
+  }
+  // equivalent values for every corresponding key, and ~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!deepEqual(a[key], b[key], opts)) { return false; }
+  }
+
+  return true;
+}
+
+module.exports = deepEqual;

package/node_modules/deep-equal/lib/is_arguments.js

@@ -0,0 +1 @@
+module.exports = require('is-arguments');

package/node_modules/deep-equal/lib/keys.js

@@ -0,0 +1 @@
+module.exports = require('object-keys');

package/node_modules/deep-equal/package.json

@@ -0,0 +1,117 @@
+{
+  "_from": "deep-equal@^1.0.0",
+  "_id": "deep-equal@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-yd9c5AdiqVcR+JjcwUQb9DkhJc8ngNr0MahEBGvDiJw8puWab2yZlh+nkasOnZP+EGTAP6rRp2JzJhJZzvNF8g==",
+  "_location": "/deep-equal",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "deep-equal@^1.0.0",
+    "name": "deep-equal",
+    "escapedName": "deep-equal",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/@turf/line-overlap",
+    "/geojson-equality"
+  ],
+  "_resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.1.1.tgz",
+  "_shasum": "b5c98c942ceffaf7cb051e24e1434a25a2e6076a",
+  "_spec": "deep-equal@^1.0.0",
+  "_where": "/Users/conway/Projects/TAKreg/node_modules/geojson-equality",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "auto-changelog": {
+    "output": "CHANGELOG.md",
+    "template": "keepachangelog",
+    "unreleased": false,
+    "commitLimit": false,
+    "backfillLimit": false
+  },
+  "bugs": {
+    "url": "https://github.com/substack/node-deep-equal/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "is-arguments": "^1.0.4",
+    "is-date-object": "^1.0.1",
+    "is-regex": "^1.0.4",
+    "object-is": "^1.0.1",
+    "object-keys": "^1.1.1",
+    "regexp.prototype.flags": "^1.2.0"
+  },
+  "deprecated": false,
+  "description": "node's assert.deepEqual algorithm",
+  "devDependencies": {
+    "@ljharb/eslint-config": "^15.0.1",
+    "auto-changelog": "^1.16.2",
+    "eslint": "^6.6.0",
+    "safe-publish-latest": "^1.1.4",
+    "tape": "^4.11.0"
+  },
+  "directories": {
+    "lib": ".",
+    "example": "example",
+    "test": "test"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/ljharb"
+  },
+  "homepage": "https://github.com/substack/node-deep-equal#readme",
+  "keywords": [
+    "equality",
+    "equal",
+    "compare"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "deep-equal",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/substack/node-deep-equal.git"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "posttest": "npx aud",
+    "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"",
+    "prepublish": "safe-publish-latest",
+    "pretest": "npm run lint",
+    "test": "npm run tests-only",
+    "tests-only": "tape test/*",
+    "version": "auto-changelog && git add CHANGELOG.md"
+  },
+  "testling": {
+    "files": "test/*.js",
+    "browsers": {
+      "ie": [
+        6,
+        7,
+        8,
+        9
+      ],
+      "ff": [
+        3.5,
+        10,
+        15
+      ],
+      "chrome": [
+        10,
+        22
+      ],
+      "safari": [
+        5.1
+      ],
+      "opera": [
+        12
+      ]
+    }
+  },
+  "version": "1.1.1"
+}

package/node_modules/deep-equal/readme.markdown

@@ -0,0 +1,57 @@
+# deep-equal
+
+Node's `assert.deepEqual() algorithm` as a standalone module.
+
+This module is around [5 times faster](https://gist.github.com/2790507)
+than wrapping `assert.deepEqual()` in a `try/catch`.
+
+[![browser support](https://ci.testling.com/substack/node-deep-equal.png)](https://ci.testling.com/substack/node-deep-equal)
+
+[![build status](https://secure.travis-ci.org/substack/node-deep-equal.png)](https://travis-ci.org/substack/node-deep-equal)
+
+# example
+
+``` js
+var equal = require('deep-equal');
+console.dir([
+    equal(
+        { a : [ 2, 3 ], b : [ 4 ] },
+        { a : [ 2, 3 ], b : [ 4 ] }
+    ),
+    equal(
+        { x : 5, y : [6] },
+        { x : 5, y : 6 }
+    )
+]);
+```
+
+# methods
+
+``` js
+var deepEqual = require('deep-equal')
+```
+
+## deepEqual(a, b, opts)
+
+Compare objects `a` and `b`, returning whether they are equal according to a
+recursive equality algorithm.
+
+If `opts.strict` is `true`, use strict equality (`===`) to compare leaf nodes.
+The default is to use coercive equality (`==`) because that's how
+`assert.deepEqual()` works by default.
+
+# install
+
+With [npm](http://npmjs.org) do:
+
+```
+npm install deep-equal
+```
+
+# test
+
+With [npm](http://npmjs.org) do:
+
+```
+npm test
+```

package/node_modules/deep-equal/test/_tape.js

@@ -0,0 +1,21 @@
+var Test = require('tape/lib/test');
+var is = require('object-is');
+var equal = require('../');
+
+function equalReversed(t, a, b, isEqual, msg, isStrict, skipReversed) {
+  var actual = isStrict ? equal(a, b, { strict: true }) : equal(a, b);
+  var suffix = isEqual ? ' are equal' : ' are not equal';
+  t.equal(actual, !!isEqual, msg + suffix);
+  if (typeof skipReversed === 'boolean' ? !skipReversed : !is(a, b)) {
+    var actualReverse = isStrict ? equal(b, a, { strict: true }) : equal(b, a);
+    t.equal(actualReverse, !!isEqual, msg + suffix + ' (reversed)');
+  }
+}
+function deepEqualTest(t, a, b, msg, isEqual, isStrictEqual, skipReversed) {
+  equalReversed(t, a, b, isEqual, msg, false, skipReversed);
+  equalReversed(t, a, b, isStrictEqual, 'strict: ' + msg, true, skipReversed);
+}
+
+Test.prototype.deepEqualTest = function (a, b, message, isEqual, isStrictEqual, skipReversed) {
+  return deepEqualTest(this, a, b, message, !!isEqual, !!isStrictEqual, skipReversed);
+};

package/node_modules/deep-equal/test/cmp.js

@@ -0,0 +1,344 @@
+var test = require('tape');
+require('./_tape');
+
+var equal = require('../');
+
+test('equal', function (t) {
+  t.deepEqualTest(
+    { a: [2, 3], b: [4] },
+    { a: [2, 3], b: [4] },
+    'two equal objects',
+    true,
+    true,
+    false
+  );
+  t.end();
+});
+
+test('not equal', function (t) {
+  t.deepEqualTest(
+    { x: 5, y: [6] },
+    { x: 5, y: 6 },
+    'two inequal objects are',
+    false,
+    false
+  );
+  t.end();
+});
+
+test('nested nulls', function (t) {
+  t.deepEqualTest(
+    [null, null, null],
+    [null, null, null],
+    'same-length arrays of nulls',
+    true,
+    true,
+    true
+  );
+  t.end();
+});
+
+test('objects with strings vs numbers', function (t) {
+  t.deepEqualTest(
+    [{ a: 3 }, { b: 4 }],
+    [{ a: '3' }, { b: '4' }],
+    'objects with equivalent string/number values',
+    true,
+    false
+  );
+  t.end();
+});
+
+test('non-objects', function (t) {
+  t.deepEqualTest(3, 3, 'same numbers', true, true, true);
+  t.deepEqualTest('beep', 'beep', 'same strings', true, true, true);
+  t.deepEqualTest('3', 3, 'numeric string and number', true, false);
+  t.deepEqualTest('3', [3], 'numeric string and array containing number', false, false);
+  t.deepEqualTest(3, [3], 'number and array containing number', false, false);
+
+  t.end();
+});
+
+test('infinities', function (t) {
+  t.deepEqualTest(Infinity, Infinity, '∞ and ∞', true, true, true);
+  t.deepEqualTest(-Infinity, -Infinity, '-∞ and -∞', true, true, true);
+  t.deepEqualTest(Infinity, -Infinity, '∞ and -∞', false, false);
+
+  t.end();
+});
+
+test('arguments class', function (t) {
+  function getArgs() {
+    return arguments;
+  }
+  t.ok(
+    equal(getArgs(1, 2, 3), getArgs(1, 2, 3)),
+    'equivalent arguments objects are equal'
+  );
+
+  t.deepEqualTest(
+    getArgs(1, 2, 3),
+    [1, 2, 3],
+    'array and arguments with same contents',
+    false,
+    false
+  );
+
+  t.end();
+});
+
+test('dates', function (t) {
+  var d0 = new Date(1387585278000);
+  var d1 = new Date('Fri Dec 20 2013 16:21:18 GMT-0800 (PST)');
+  t.deepEqualTest(d0, d1, 'equivalent Dates', true, true);
+  t.end();
+});
+
+test('buffers', function (t) {
+  /* eslint no-buffer-constructor: 1, new-cap: 1 */
+  t.ok(equal(Buffer('xyz'), Buffer('xyz')), 'buffers with same contents are equal');
+  t.ok(equal(Buffer('xyz'), Buffer('xyz'), { strict: true }), 'strict: buffers with same contents are equal');
+
+  t.deepEqualTest(
+    Buffer('abc'),
+    Buffer('xyz'),
+    'buffers with different contents',
+    false,
+    false
+  );
+
+  t.deepEqualTest(
+    Buffer(''),
+    [],
+    'empty buffer and empty array',
+    false,
+    false
+  );
+
+  t.end();
+});
+
+test('booleans and arrays', function (t) {
+  t.deepEqualTest(
+    true,
+    [],
+    'true and an empty array',
+    false,
+    false
+  );
+  t.deepEqualTest(
+    false,
+    [],
+    'false and an empty array',
+    true,
+    false
+  );
+  t.end();
+});
+
+test('arrays initiated', function (t) {
+  var a0 = [
+      undefined,
+      null,
+      -1,
+      0,
+      1,
+      false,
+      true,
+      undefined,
+      '',
+      'abc',
+      null,
+      undefined
+    ],
+    a1 = [
+      undefined,
+      null,
+      -1,
+      0,
+      1,
+      false,
+      true,
+      undefined,
+      '',
+      'abc',
+      null,
+      undefined
+    ];
+
+  t.ok(equal(a0, a1));
+  t.end();
+});
+
+// eslint-disable-next-line max-statements
+test('arrays assigned', function (t) {
+  var a0 = [
+    undefined,
+    null,
+    -1,
+    0,
+    1,
+    false,
+    true,
+    undefined,
+    '',
+    'abc',
+    null,
+    undefined
+  ];
+  var a1 = [];
+
+  a1[0] = undefined;
+  a1[1] = null;
+  a1[2] = -1;
+  a1[3] = 0;
+  a1[4] = 1;
+  a1[5] = false;
+  a1[6] = true;
+  a1[7] = undefined;
+  a1[8] = '';
+  a1[9] = 'abc';
+  a1[10] = null;
+  a1[11] = undefined;
+  a1.length = 12;
+
+  t.deepEqualTest(a0, a1, 'a literal array and an assigned array', true, true);
+  t.end();
+});
+
+// eslint-disable-next-line max-statements
+test('arrays push', function (t) {
+  var a0 = [
+      undefined,
+      null,
+      -1,
+      0,
+      1,
+      false,
+      true,
+      undefined,
+      '',
+      'abc',
+      null,
+      undefined
+    ],
+    a1 = [];
+
+  a1.push(undefined);
+  a1.push(null);
+  a1.push(-1);
+  a1.push(0);
+  a1.push(1);
+  a1.push(false);
+  a1.push(true);
+  a1.push(undefined);
+  a1.push('');
+  a1.push('abc');
+  a1.push(null);
+  a1.push(undefined);
+  a1.length = 12;
+
+  t.deepEqualTest(a0, a1, 'a literal array and a pushed array', true, true);
+  t.end();
+});
+
+test('null == undefined', function (t) {
+  t.deepEqualTest(null, undefined, 'null and undefined', true, false);
+
+  t.end();
+});
+
+test('NaNs', function (t) {
+  t.notOk(equal(NaN, NaN), 'NaN is not NaN');
+  t.ok(equal(NaN, NaN, { strict: true }), 'strict: NaN is NaN');
+
+  t.notOk(equal({ a: NaN }, { a: NaN }), 'two equiv objects with a NaN value are not equiv');
+  t.ok(equal({ a: NaN }, { a: NaN }, { strict: true }), 'strict: two equiv objects with a NaN value are equiv');
+
+  t.notOk(equal(NaN, 1), 'NaN !== 1');
+  t.notOk(equal(NaN, 1, { strict: true }), 'strict: NaN !== 1');
+
+  t.end();
+});
+
+test('zeroes', function (t) {
+  t.deepEqualTest(0, -0, '0 and -0', true, false);
+
+  t.deepEqualTest({ a: 0 }, { a: -0 }, 'two objects with a same-keyed 0/-0 value', true, false);
+
+  t.end();
+});
+
+test('Object.create', { skip: !Object.create }, function (t) {
+  var a = { a: 'A' };
+  var b = Object.create(a);
+  b.b = 'B';
+  var c = Object.create(a);
+  c.b = 'C';
+
+  t.deepEqualTest(
+    b,
+    c,
+    'two objects with the same [[Prototype]] but a different own property',
+    false,
+    false
+  );
+
+  t.end();
+});
+
+test('Object.create(null)', { skip: !Object.create }, function (t) {
+  t.deepEqualTest(
+    Object.create(null),
+    Object.create(null),
+    'two empty null objects',
+    true,
+    true,
+    true
+  );
+
+  t.deepEqualTest(
+    Object.create(null, { a: { value: 'b' } }),
+    Object.create(null, { a: { value: 'b' } }),
+    'two null objects with the same property pair',
+    true,
+    true,
+    true
+  );
+
+  t.end();
+});
+
+test('regexes vs dates', function (t) {
+  var d = new Date(1387585278000);
+  var r = /abc/;
+
+  t.deepEqualTest(d, r, 'Date and RegExp', false, false);
+
+  t.end();
+});
+
+test('regexen', function (t) {
+  t.deepEqualTest(/abc/, /xyz/, 'two different regexes', false, false);
+  t.deepEqualTest(/abc/, /abc/, 'two abc regexes', true, true, false);
+  t.deepEqualTest(/xyz/, /xyz/, 'two xyz regexes', true, true, false);
+
+  t.end();
+});
+
+test('arrays and objects', function (t) {
+  t.deepEqualTest([], {}, 'empty array and empty object', true, true);
+  t.deepEqualTest([], { length: 0 }, 'empty array and empty arraylike object', false, false);
+  t.deepEqualTest([1], { 0: 1 }, 'array and similar object', true, true);
+
+  t.end();
+});
+
+test('functions', function (t) {
+  function f() {}
+
+  t.deepEqualTest(f, f, 'a function and itself', true, true, true);
+  t.deepEqualTest(function () {}, function () {}, 'two distinct functions', false, false, true);
+
+  t.end();
+});

package/node_modules/define-properties/.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+indent_style = tab;
+insert_final_newline = true;
+quote_type = auto;
+space_after_anonymous_functions = true;
+space_after_control_statements = true;
+spaces_around_operators = true;
+trim_trailing_whitespace = true;
+spaces_in_brackets = false;
+end_of_line = lf;
+

package/node_modules/define-properties/.eslintrc

@@ -0,0 +1,12 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"rules": {
+		"id-length": [2, { "min": 1, "max": 35 }],
+		"max-lines-per-function": [2, 100],
+		"max-params": [2, 4],
+		"max-statements": [2, 13]
+	}
+}