.

node_modules/object.getownpropertydescriptors/test/.eslintrc

@@ -0,0 +1,8 @@
+{
+	"rules": {
+		"max-nested-callbacks": [2, 3],
+		"max-statements": [2, 15],
+		"max-statements-per-line": [2, { "max": 2 }],
+		"no-invalid-this": [1]
+	}
+}

node_modules/object.getownpropertydescriptors/test/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var getDescriptors = require('../');
+var test = require('tape');
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+	t.test('bad object/this value', function (st) {
+		st.throws(function () { return getDescriptors(undefined); }, TypeError, 'undefined is not an object');
+		st.throws(function () { return getDescriptors(null); }, TypeError, 'null is not an object');
+		st.end();
+	});
+
+	runTests(getDescriptors, t);
+
+	t.end();
+});

node_modules/object.getownpropertydescriptors/test/shimmed.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var getDescriptors = require('../');
+getDescriptors.shim();
+
+var test = require('tape');
+var defineProperties = require('define-properties');
+var runTests = require('./tests');
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var functionsHaveNames = function f() {}.name === 'f';
+
+test('shimmed', function (t) {
+	t.equal(Object.getOwnPropertyDescriptors.length, 1, 'Object.getOwnPropertyDescriptors has a length of 1');
+	t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+		st.equal(Object.getOwnPropertyDescriptors.name, 'getOwnPropertyDescriptors', 'Object.getOwnPropertyDescriptors has name "getOwnPropertyDescriptors"');
+		st.end();
+	});
+
+	t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+		et.equal(false, isEnumerable.call(Object, 'getOwnPropertyDescriptors'), 'Object.getOwnPropertyDescriptors is not enumerable');
+		et.end();
+	});
+
+	var supportsStrictMode = (function () { return typeof this === 'undefined'; }());
+
+	t.test('bad object/this value', { skip: !supportsStrictMode }, function (st) {
+		st.throws(function () { return getDescriptors(undefined, 'a'); }, TypeError, 'undefined is not an object');
+		st.throws(function () { return getDescriptors(null, 'a'); }, TypeError, 'null is not an object');
+		st.end();
+	});
+
+	runTests(Object.getOwnPropertyDescriptors, t);
+
+	t.end();
+});

node_modules/object.getownpropertydescriptors/test/tests.js

@@ -0,0 +1,127 @@
+'use strict';
+
+module.exports = function (getDescriptors, t) {
+	var enumDescriptor = {
+		configurable: true,
+		enumerable: false,
+		value: true,
+		writable: false
+	};
+	var writableDescriptor = {
+		configurable: true,
+		enumerable: true,
+		value: 42,
+		writable: true
+	};
+
+	t.test('works with Object.prototype poisoned setter', { skip: !Object.defineProperty }, function (st) {
+		var key = 'foo';
+
+		var obj = {};
+		obj[key] = 42;
+
+		var expected = {};
+		expected[key] = {
+			configurable: true,
+			enumerable: true,
+			value: 42,
+			writable: true
+		};
+
+		/* eslint-disable no-extend-native, accessor-pairs */
+		Object.defineProperty(Object.prototype, key, { configurable: true, set: function (v) { throw new Error(v); } });
+		/* eslint-enable no-extend-native, accessor-pairs */
+
+		var hasOwnNamesBug = false;
+		try {
+			Object.getOwnPropertyNames(obj);
+		} catch (e) {
+			// v8 in node 0.6 - 0.12 has a bug :-(
+			hasOwnNamesBug = true;
+			st.comment('SKIP: this engine has a bug with Object.getOwnPropertyNames: it can not handle a throwing setter on Object.prototype.');
+		}
+
+		if (!hasOwnNamesBug) {
+			st.doesNotThrow(function () {
+				var result = getDescriptors(obj);
+				st.deepEqual(result, expected, 'got expected descriptors');
+			});
+		}
+
+		/* eslint-disable no-extend-native */
+		delete Object.prototype[key];
+		/* eslint-enable no-extend-native */
+		st.end();
+	});
+
+	t.test('gets all expected non-Symbol descriptors', function (st) {
+		var obj = { normal: Infinity };
+		Object.defineProperty(obj, 'enumerable', enumDescriptor);
+		Object.defineProperty(obj, 'writable', writableDescriptor);
+
+		var descriptors = getDescriptors(obj);
+
+		st.deepEqual(descriptors, {
+			enumerable: enumDescriptor,
+			normal: {
+				configurable: true,
+				enumerable: true,
+				value: Infinity,
+				writable: true
+			},
+			writable: writableDescriptor
+		});
+		st.end();
+	});
+
+	var supportsSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';
+	t.test('gets Symbol descriptors too', { skip: !supportsSymbols }, function (st) {
+		var symbol = Symbol();
+		var symDescriptor = {
+			configurable: false,
+			enumerable: true,
+			value: [symbol],
+			writable: true
+		};
+		var obj = { normal: Infinity };
+		Object.defineProperty(obj, 'enumerable', enumDescriptor);
+		Object.defineProperty(obj, 'writable', writableDescriptor);
+		Object.defineProperty(obj, 'symbol', symDescriptor);
+
+		var descriptors = getDescriptors(obj);
+
+		st.deepEqual(descriptors, {
+			enumerable: enumDescriptor,
+			normal: {
+				configurable: true,
+				enumerable: true,
+				value: Infinity,
+				writable: true
+			},
+			symbol: symDescriptor,
+			writable: writableDescriptor
+		});
+		st.end();
+	});
+
+	/* global Proxy */
+	var supportsProxy = typeof Proxy === 'function';
+	t.test('Proxies that return an undefined descriptor', { skip: !supportsProxy }, function (st) {
+		var obj = { foo: true };
+		var fooDescriptor = Object.getOwnPropertyDescriptor(obj, 'foo');
+
+		var proxy = new Proxy(obj, {
+			getOwnPropertyDescriptor: function (target, key) {
+				return Object.getOwnPropertyDescriptor(target, key);
+			},
+			ownKeys: function () {
+				return [
+					'foo',
+					'bar'
+				];
+			}
+		});
+		st.deepEqual(getDescriptors(proxy), { foo: fooDescriptor }, 'object has no descriptors');
+		st.end();
+	});
+};