meteor-node-stubs 1.2.16 → 1.2.17

package/node_modules/hash.js/lib/hash/utils.js

@@ -0,0 +1,278 @@
+'use strict';
+
+var assert = require('minimalistic-assert');
+var inherits = require('inherits');
+
+exports.inherits = inherits;
+
+function isSurrogatePair(msg, i) {
+  if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {
+    return false;
+  }
+  if (i < 0 || i + 1 >= msg.length) {
+    return false;
+  }
+  return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;
+}
+
+function toArray(msg, enc) {
+  if (Array.isArray(msg))
+    return msg.slice();
+  if (!msg)
+    return [];
+  var res = [];
+  if (typeof msg === 'string') {
+    if (!enc) {
+      // Inspired by stringToUtf8ByteArray() in closure-library by Google
+      // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
+      // Apache License 2.0
+      // https://github.com/google/closure-library/blob/master/LICENSE
+      var p = 0;
+      for (var i = 0; i < msg.length; i++) {
+        var c = msg.charCodeAt(i);
+        if (c < 128) {
+          res[p++] = c;
+        } else if (c < 2048) {
+          res[p++] = (c >> 6) | 192;
+          res[p++] = (c & 63) | 128;
+        } else if (isSurrogatePair(msg, i)) {
+          c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);
+          res[p++] = (c >> 18) | 240;
+          res[p++] = ((c >> 12) & 63) | 128;
+          res[p++] = ((c >> 6) & 63) | 128;
+          res[p++] = (c & 63) | 128;
+        } else {
+          res[p++] = (c >> 12) | 224;
+          res[p++] = ((c >> 6) & 63) | 128;
+          res[p++] = (c & 63) | 128;
+        }
+      }
+    } else if (enc === 'hex') {
+      msg = msg.replace(/[^a-z0-9]+/ig, '');
+      if (msg.length % 2 !== 0)
+        msg = '0' + msg;
+      for (i = 0; i < msg.length; i += 2)
+        res.push(parseInt(msg[i] + msg[i + 1], 16));
+    }
+  } else {
+    for (i = 0; i < msg.length; i++)
+      res[i] = msg[i] | 0;
+  }
+  return res;
+}
+exports.toArray = toArray;
+
+function toHex(msg) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++)
+    res += zero2(msg[i].toString(16));
+  return res;
+}
+exports.toHex = toHex;
+
+function htonl(w) {
+  var res = (w >>> 24) |
+            ((w >>> 8) & 0xff00) |
+            ((w << 8) & 0xff0000) |
+            ((w & 0xff) << 24);
+  return res >>> 0;
+}
+exports.htonl = htonl;
+
+function toHex32(msg, endian) {
+  var res = '';
+  for (var i = 0; i < msg.length; i++) {
+    var w = msg[i];
+    if (endian === 'little')
+      w = htonl(w);
+    res += zero8(w.toString(16));
+  }
+  return res;
+}
+exports.toHex32 = toHex32;
+
+function zero2(word) {
+  if (word.length === 1)
+    return '0' + word;
+  else
+    return word;
+}
+exports.zero2 = zero2;
+
+function zero8(word) {
+  if (word.length === 7)
+    return '0' + word;
+  else if (word.length === 6)
+    return '00' + word;
+  else if (word.length === 5)
+    return '000' + word;
+  else if (word.length === 4)
+    return '0000' + word;
+  else if (word.length === 3)
+    return '00000' + word;
+  else if (word.length === 2)
+    return '000000' + word;
+  else if (word.length === 1)
+    return '0000000' + word;
+  else
+    return word;
+}
+exports.zero8 = zero8;
+
+function join32(msg, start, end, endian) {
+  var len = end - start;
+  assert(len % 4 === 0);
+  var res = new Array(len / 4);
+  for (var i = 0, k = start; i < res.length; i++, k += 4) {
+    var w;
+    if (endian === 'big')
+      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];
+    else
+      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];
+    res[i] = w >>> 0;
+  }
+  return res;
+}
+exports.join32 = join32;
+
+function split32(msg, endian) {
+  var res = new Array(msg.length * 4);
+  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
+    var m = msg[i];
+    if (endian === 'big') {
+      res[k] = m >>> 24;
+      res[k + 1] = (m >>> 16) & 0xff;
+      res[k + 2] = (m >>> 8) & 0xff;
+      res[k + 3] = m & 0xff;
+    } else {
+      res[k + 3] = m >>> 24;
+      res[k + 2] = (m >>> 16) & 0xff;
+      res[k + 1] = (m >>> 8) & 0xff;
+      res[k] = m & 0xff;
+    }
+  }
+  return res;
+}
+exports.split32 = split32;
+
+function rotr32(w, b) {
+  return (w >>> b) | (w << (32 - b));
+}
+exports.rotr32 = rotr32;
+
+function rotl32(w, b) {
+  return (w << b) | (w >>> (32 - b));
+}
+exports.rotl32 = rotl32;
+
+function sum32(a, b) {
+  return (a + b) >>> 0;
+}
+exports.sum32 = sum32;
+
+function sum32_3(a, b, c) {
+  return (a + b + c) >>> 0;
+}
+exports.sum32_3 = sum32_3;
+
+function sum32_4(a, b, c, d) {
+  return (a + b + c + d) >>> 0;
+}
+exports.sum32_4 = sum32_4;
+
+function sum32_5(a, b, c, d, e) {
+  return (a + b + c + d + e) >>> 0;
+}
+exports.sum32_5 = sum32_5;
+
+function sum64(buf, pos, ah, al) {
+  var bh = buf[pos];
+  var bl = buf[pos + 1];
+
+  var lo = (al + bl) >>> 0;
+  var hi = (lo < al ? 1 : 0) + ah + bh;
+  buf[pos] = hi >>> 0;
+  buf[pos + 1] = lo;
+}
+exports.sum64 = sum64;
+
+function sum64_hi(ah, al, bh, bl) {
+  var lo = (al + bl) >>> 0;
+  var hi = (lo < al ? 1 : 0) + ah + bh;
+  return hi >>> 0;
+}
+exports.sum64_hi = sum64_hi;
+
+function sum64_lo(ah, al, bh, bl) {
+  var lo = al + bl;
+  return lo >>> 0;
+}
+exports.sum64_lo = sum64_lo;
+
+function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
+  var carry = 0;
+  var lo = al;
+  lo = (lo + bl) >>> 0;
+  carry += lo < al ? 1 : 0;
+  lo = (lo + cl) >>> 0;
+  carry += lo < cl ? 1 : 0;
+  lo = (lo + dl) >>> 0;
+  carry += lo < dl ? 1 : 0;
+
+  var hi = ah + bh + ch + dh + carry;
+  return hi >>> 0;
+}
+exports.sum64_4_hi = sum64_4_hi;
+
+function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
+  var lo = al + bl + cl + dl;
+  return lo >>> 0;
+}
+exports.sum64_4_lo = sum64_4_lo;
+
+function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  var carry = 0;
+  var lo = al;
+  lo = (lo + bl) >>> 0;
+  carry += lo < al ? 1 : 0;
+  lo = (lo + cl) >>> 0;
+  carry += lo < cl ? 1 : 0;
+  lo = (lo + dl) >>> 0;
+  carry += lo < dl ? 1 : 0;
+  lo = (lo + el) >>> 0;
+  carry += lo < el ? 1 : 0;
+
+  var hi = ah + bh + ch + dh + eh + carry;
+  return hi >>> 0;
+}
+exports.sum64_5_hi = sum64_5_hi;
+
+function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  var lo = al + bl + cl + dl + el;
+
+  return lo >>> 0;
+}
+exports.sum64_5_lo = sum64_5_lo;
+
+function rotr64_hi(ah, al, num) {
+  var r = (al << (32 - num)) | (ah >>> num);
+  return r >>> 0;
+}
+exports.rotr64_hi = rotr64_hi;
+
+function rotr64_lo(ah, al, num) {
+  var r = (ah << (32 - num)) | (al >>> num);
+  return r >>> 0;
+}
+exports.rotr64_lo = rotr64_lo;
+
+function shr64_hi(ah, al, num) {
+  return ah >>> num;
+}
+exports.shr64_hi = shr64_hi;
+
+function shr64_lo(ah, al, num) {
+  var r = (ah << (32 - num)) | (al >>> num);
+  return r >>> 0;
+}
+exports.shr64_lo = shr64_lo;

package/node_modules/hash.js/lib/hash.d.ts

@@ -0,0 +1,106 @@
+declare var hash: Hash;
+
+declare module "hash.js" {
+    export = hash;
+}
+
+interface BlockHash<T> {
+    hmacStrength: number
+    padLength: number
+    endian: 'big' | 'little'
+}
+
+interface MessageDigest<T> {
+    blockSize: number
+    outSize: number
+    update(msg: any, enc?: 'hex'): T
+    digest(): number[]
+    digest(enc: 'hex'): string
+}
+
+interface Hash {
+    hmac: HmacConstructor
+    ripemd: RipemdSet
+    ripemd160: Ripemd160Constructor
+    sha: ShaSet
+    sha1: Sha1Constructor
+    sha224: Sha224Constructor
+    sha256: Sha256Constructor
+    sha384: Sha384Constructor
+    sha512: Sha512Constructor
+    utils: Utils
+}
+
+interface Utils {
+    toArray(msg: any, enc: 'hex'): Array<number>
+    toHex(msg: any): string
+}
+
+interface RipemdSet {
+    ripemd160: Ripemd160Constructor
+}
+
+interface ShaSet {
+    sha1: Sha1Constructor
+    sha224: Sha224Constructor
+    sha256: Sha256Constructor
+    sha384: Sha384Constructor
+    sha512: Sha512Constructor
+}
+
+interface HmacConstructor { (hash: BlockHash<any>, key: any, enc?: 'hex'): Hmac }
+interface Ripemd160Constructor { (): Ripemd160 }
+interface Sha1Constructor { (): Sha1; }
+interface Sha224Constructor { (): Sha224; }
+interface Sha256Constructor { (): Sha256; }
+interface Sha384Constructor { (): Sha384; }
+interface Sha512Constructor { (): Sha512; }
+
+interface Hmac extends MessageDigest<Hmac> {
+    blockSize: 512
+    outSize: 160
+}
+
+interface Ripemd160 extends BlockHash<Ripemd160>, MessageDigest<Ripemd160> {
+    blockSize: 512
+    hmacStrength: 192
+    outSize: 160
+    padLength: 64
+    endian: 'little'
+}
+
+interface Sha1 extends BlockHash<Sha1>, MessageDigest<Sha1> {
+    blockSize: 512
+    hmacStrength: 80
+    outSize: 160
+    padLength: 64
+    endian: 'big'
+}
+interface Sha224 extends BlockHash<Sha224>, MessageDigest<Sha224> {
+    blockSize: 512
+    hmacStrength: 192
+    outSize: 224
+    padLength: 64
+    endian: 'big'
+}
+interface Sha256 extends BlockHash<Sha256>, MessageDigest<Sha256> {
+    blockSize: 512
+    hmacStrength: 192
+    outSize: 256
+    padLength: 64
+    endian: 'big'
+}
+interface Sha384 extends BlockHash<Sha384>, MessageDigest<Sha384> {
+    blockSize: 1024
+    hmacStrength: 192
+    outSize: 384
+    padLength: 128
+    endian: 'big'
+}
+interface Sha512 extends BlockHash<Sha512>, MessageDigest<Sha512> {
+    blockSize: 1024
+    hmacStrength: 192
+    outSize: 512
+    padLength: 128
+    endian: 'big'
+}

package/node_modules/hash.js/lib/hash.js

@@ -0,0 +1,15 @@
+var hash = exports;
+
+hash.utils = require('./hash/utils');
+hash.common = require('./hash/common');
+hash.sha = require('./hash/sha');
+hash.ripemd = require('./hash/ripemd');
+hash.hmac = require('./hash/hmac');
+
+// Proxy hash functions to the main object
+hash.sha1 = hash.sha.sha1;
+hash.sha256 = hash.sha.sha256;
+hash.sha224 = hash.sha.sha224;
+hash.sha384 = hash.sha.sha384;
+hash.sha512 = hash.sha.sha512;
+hash.ripemd160 = hash.ripemd.ripemd160;

package/node_modules/hash.js/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "hash.js",
+  "version": "1.1.7",
+  "description": "Various hash functions that could be run by both browser and node",
+  "main": "lib/hash.js",
+  "typings": "lib/hash.d.ts",
+  "scripts": {
+    "test": "mocha --reporter=spec test/*-test.js && npm run lint",
+    "lint": "eslint lib/*.js lib/**/*.js lib/**/**/*.js test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:indutny/hash.js"
+  },
+  "keywords": [
+    "hash",
+    "sha256",
+    "sha224",
+    "hmac"
+  ],
+  "author": "Fedor Indutny <fedor@indutny.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/indutny/hash.js/issues"
+  },
+  "homepage": "https://github.com/indutny/hash.js",
+  "dependencies": {
+    "inherits": "^2.0.3",
+    "minimalistic-assert": "^1.0.1"
+  },
+  "devDependencies": {
+    "eslint": "^4.19.1",
+    "mocha": "^5.2.0"
+  }
+}

package/node_modules/hash.js/test/hash-test.js

@@ -0,0 +1,140 @@
+'use strict';
+/* global describe it */
+
+var assert = require('assert');
+var crypto = require('crypto');
+var hash = require('../');
+
+describe('Hash', function() {
+  function test(fn, cases) {
+    for (var i = 0; i < cases.length; i++) {
+      var msg = cases[i][0];
+      var res = cases[i][1];
+      var enc = cases[i][2];
+
+      var dgst = fn().update(msg, enc).digest('hex');
+      assert.equal(dgst, res);
+
+      // Split message
+      dgst = fn().update(msg.slice(0, 2), enc)
+        .update(msg.slice(2), enc)
+        .digest('hex');
+      assert.equal(dgst, res);
+    }
+  }
+
+  it('should support sha256', function() {
+    assert.equal(hash.sha256.blockSize, 512);
+    assert.equal(hash.sha256.outSize, 256);
+
+    test(hash.sha256, [
+      [ 'abc',
+        'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad' ],
+      [ 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1' ],
+      [ 'deadbeef',
+        '5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953',
+        'hex' ],
+    ]);
+  });
+
+  it('should support sha224', function() {
+    assert.equal(hash.sha224.blockSize, 512);
+    assert.equal(hash.sha224.outSize, 224);
+
+    test(hash.sha224, [
+      [ 'abc',
+        '23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7' ],
+      [ 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525' ],
+      [ 'deadbeef',
+        '55b9eee5f60cc362ddc07676f620372611e22272f60fdbec94f243f8',
+        'hex' ],
+    ]);
+  });
+
+  it('should support ripemd160', function() {
+    assert.equal(hash.ripemd160.blockSize, 512);
+    assert.equal(hash.ripemd160.outSize, 160);
+
+    test(hash.ripemd160, [
+      [ '', '9c1185a5c5e9fc54612808977ee8f548b2258d31'],
+      [ 'abc',
+        '8eb208f7e05d987a9b044a8e98c6b087f15a0bfc' ],
+      [ 'message digest',
+        '5d0689ef49d2fae572b881b123a85ffa21595f36' ],
+      [ 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '12a053384a9c0c88e405a06c27dcf49ada62eb2b' ],
+      [ 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+        'b0e20b6e3116640286ed3a87a5713079b21f5189' ],
+    ]);
+  });
+
+  it('should support sha1', function() {
+    assert.equal(hash.sha1.blockSize, 512);
+    assert.equal(hash.sha1.outSize, 160);
+
+    test(hash.sha1, [
+      [ '',
+        'da39a3ee5e6b4b0d3255bfef95601890afd80709' ],
+      [ 'abc',
+        'a9993e364706816aba3e25717850c26c9cd0d89d' ],
+      [ 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',
+        '84983e441c3bd26ebaae4aa1f95129e5e54670f1' ],
+      [ 'deadbeef',
+        'd78f8bb992a56a597f6c7a1fb918bb78271367eb',
+        'hex' ],
+    ]);
+  });
+
+  it('should support sha512', function() {
+    assert.equal(hash.sha512.blockSize, 1024);
+    assert.equal(hash.sha512.outSize, 512);
+
+    test(hash.sha512, [
+      [ 'abc',
+        'ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a' +
+            '2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f'
+      ],
+      [
+        'abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn' +
+          'hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu',
+        '8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018' +
+          '501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909'
+      ]
+    ]);
+  });
+
+  it('should support sha384', function() {
+    assert.equal(hash.sha384.blockSize, 1024);
+    assert.equal(hash.sha384.outSize, 384);
+
+    test(hash.sha384, [
+      [ 'abc',
+        'cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed' +
+            '8086072ba1e7cc2358baeca134c825a7'
+      ],
+      [
+        'abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn' +
+          'hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu',
+        '09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712' +
+          'fcc7c71a557e2db966c3e9fa91746039'
+      ]
+    ]);
+  });
+
+  it('handles utf8 in strings just like crypto', function() {
+    const algorithm = 'sha256';
+    test(hash[algorithm], [
+      'hello', // one byte per character
+      'привет', // two bytes per character
+      '您好', // three bytes per character
+      '👋', // four bytes per character
+      'hello привет 您好 👋!!!' // mixed character lengths
+    ].map(str => [str, crypto
+      .createHash(algorithm)
+      .update(str)
+      .digest('hex')]));
+  });
+
+});

package/node_modules/hash.js/test/hmac-test.js

@@ -0,0 +1,62 @@
+'use strict';
+/* global describe it */
+
+var assert = require('assert');
+var hash = require('../');
+
+describe('Hmac', function() {
+  describe('mixed test vector', function() {
+    test({
+      name: 'nist 1',
+      key: '00010203 04050607 08090A0B 0C0D0E0F' +
+           '10111213 14151617 18191A1B 1C1D1E1F 20212223 24252627' +
+           '28292A2B 2C2D2E2F 30313233 34353637 38393A3B 3C3D3E3F',
+      msg: 'Sample message for keylen=blocklen',
+      res: '8bb9a1db9806f20df7f77b82138c7914d174d59e13dc4d0169c9057b133e1d62'
+    });
+    test({
+      name: 'nist 2',
+      key: '00010203 04050607' +
+           '08090A0B 0C0D0E0F 10111213 14151617 18191A1B 1C1D1E1F',
+      msg: 'Sample message for keylen<blocklen',
+      res: 'a28cf43130ee696a98f14a37678b56bcfcbdd9e5cf69717fecf5480f0ebdf790'
+    });
+    test({
+      name: 'nist 3',
+      key: '00010203' +
+           '04050607 08090A0B 0C0D0E0F 10111213 14151617 18191A1B' +
+           '1C1D1E1F 20212223 24252627 28292A2B 2C2D2E2F 30313233' +
+           '34353637 38393A3B 3C3D3E3F 40414243 44454647 48494A4B' +
+           '4C4D4E4F 50515253 54555657 58595A5B 5C5D5E5F 60616263',
+      msg: 'Sample message for keylen=blocklen',
+      res: 'bdccb6c72ddeadb500ae768386cb38cc41c63dbb0878ddb9c7a38a431b78378d'
+    });
+    test({
+      name: 'nist 4',
+      key: '00' +
+           '01020304 05060708 090A0B0C 0D0E0F10 11121314 15161718' +
+           '191A1B1C 1D1E1F20 21222324 25262728 292A2B2C 2D2E2F30',
+      msg: 'Sample message for keylen<blocklen, with truncated tag',
+      res: '27a8b157839efeac98df070b331d593618ddb985d403c0c786d23b5d132e57c7'
+    });
+    test({
+      name: 'regression 1',
+      key: '48f38d0c6a344959cc94502b7b5e8dffb6a5f41795d9066fc9a649557167ee2f',
+      msg: '1d495eef7761b65dccd0a983d2d7204fea28b5c81f1758046e062eb043755ea1',
+      msgEnc: 'hex',
+      res: 'cf5ad5984f9e43917aa9087380dac46e410ddc8a7731859c84e9d0f31bd43655'
+    });
+
+    function test(opt) {
+      it('should not fail at ' + opt.name, function() {
+        var h = hash.hmac(hash.sha256, opt.key, 'hex');
+        assert.equal(h.update(opt.msg, opt.msgEnc).digest('hex'), opt.res);
+        h = hash.hmac(hash.sha256, opt.key, 'hex');
+        assert.equal(h
+          .update(opt.msg.slice(0, 10), opt.msgEnc)
+          .update(opt.msg.slice(10), opt.msgEnc)
+          .digest('hex'), opt.res);
+      });
+    }
+  });
+});

package/node_modules/hasown/.eslintrc

@@ -0,0 +1,5 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+}

package/node_modules/hasown/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/hasown
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with a single custom sponsorship URL

package/node_modules/hasown/.nycrc

@@ -0,0 +1,13 @@
+{
+	"all": true,
+	"check-coverage": false,
+	"reporter": ["text-summary", "text", "html", "json"],
+	"lines": 86,
+	"statements": 85.93,
+	"functions": 82.43,
+	"branches": 76.06,
+	"exclude": [
+		"coverage",
+		"test"
+	]
+}

package/node_modules/hasown/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v2.0.0](https://github.com/inspect-js/hasOwn/compare/v1.0.1...v2.0.0) - 2023-10-19
+
+### Commits
+
+- revamped implementation, tests, readme [`72bf8b3`](https://github.com/inspect-js/hasOwn/commit/72bf8b338e77a638f0a290c63ffaed18339c36b4)
+- [meta] revamp package.json [`079775f`](https://github.com/inspect-js/hasOwn/commit/079775fb1ec72c1c6334069593617a0be3847458)
+- Only apps should have lockfiles [`6640e23`](https://github.com/inspect-js/hasOwn/commit/6640e233d1bb8b65260880f90787637db157d215)
+
+## v1.0.1 - 2023-10-10
+
+### Commits
+
+- Initial commit [`8dbfde6`](https://github.com/inspect-js/hasOwn/commit/8dbfde6e8fb0ebb076fab38d138f2984eb340a62)