govuk_publishing_components 16.29.0 → 17.0.0

data/node_modules/type/plain-function/ensure.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var resolveException = require("../lib/resolve-exception")
+  , is               = require("./is");
+
+module.exports = function (value/*, options*/) {
+	if (is(value)) return value;
+	return resolveException(value, "%v is not a plain function", arguments[1]);
+};

data/node_modules/type/plain-function/is.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var isFunction = require("../function/is");
+
+var classRe = /^\s*class[\s{/}]/, functionToString = Function.prototype.toString;
+
+module.exports = function (value) {
+	if (!isFunction(value)) return false;
+	if (classRe.test(functionToString.call(value))) return false;
+	return true;
+};

data/node_modules/type/plain-object/ensure.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var resolveException = require("../lib/resolve-exception")
+  , is               = require("./is");
+
+module.exports = function (value/*, options*/) {
+	if (is(value)) return value;
+	return resolveException(value, "%v is not a plain object", arguments[1]);
+};

data/node_modules/type/plain-object/is.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var isObject    = require("../object/is")
+  , isPrototype = require("../prototype/is");
+
+var getPrototypeOf;
+if (typeof Object.getPrototypeOf === "function") {
+	getPrototypeOf = Object.getPrototypeOf;
+} else if ({}.__proto__ === Object.prototype) {
+	getPrototypeOf = function (object) { return object.__proto__; };
+}
+
+module.exports = function (value) {
+	if (!isObject(value)) return false;
+	var prototype;
+	if (getPrototypeOf) {
+		prototype = getPrototypeOf(value);
+	} else {
+		try {
+			var valueConstructor = value.constructor;
+			if (valueConstructor) prototype = valueConstructor.prototype;
+		} catch (error) {
+			return false;
+		}
+	}
+	if (prototype && !hasOwnProperty.call(prototype, "propertyIsEnumerable")) return false;
+	return !isPrototype(value);
+};

data/node_modules/type/promise/ensure.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var resolveException = require("../lib/resolve-exception")
+  , is               = require("./is");
+
+module.exports = function (value/*, options*/) {
+	if (is(value)) return value;
+	return resolveException(value, "%v is not a promise", arguments[1]);
+};

data/node_modules/type/promise/is.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var isPrototype = require("../prototype/is");
+
+// In theory we could rely on Symbol.toStringTag directly,
+// still early native implementation (e.g. in FF) predated symbols
+var objectToString = Object.prototype.toString
+  , objectTaggedString = objectToString.call(Promise.resolve());
+
+module.exports = function (value) {
+	if (!value) return false;
+
+	// Sanity check (reject objects which do not expose common Promise interface)
+	try {
+		if (typeof value.then !== "function") return false;
+		if (typeof value["catch"] !== "function") return false;
+	} catch (error) {
+		return false;
+	}
+
+	// Ensure its native Promise object (has [[PromiseState]] slot)
+	// Note: it's not 100% precise as string tag may be overriden
+	// and other objects could be hacked to expose it
+	if (objectToString.call(value) !== objectTaggedString) return false;
+
+	return !isPrototype(value);
+};

data/node_modules/type/prototype/is.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var isObject = require("../object/is");
+
+module.exports = function (value) {
+	if (!isObject(value)) return false;
+	try {
+		if (!value.constructor) return false;
+		return value.constructor.prototype === value;
+	} catch (error) {
+		return false;
+	}
+};

data/node_modules/type/reg-exp/ensure.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var resolveException = require("../lib/resolve-exception")
+  , is               = require("./is");
+
+module.exports = function (value/*, options*/) {
+	if (is(value)) return value;
+	return resolveException(value, "%v is not a regular expression object", arguments[1]);
+};

data/node_modules/type/reg-exp/is.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var isToStringTagSupported = require("../lib/is-to-string-tag-supported")
+  , isPrototype            = require("../prototype/is");
+
+var regExpTest = RegExp.prototype.test
+  , objectToString = Object.prototype.toString
+  , objectTaggedString = objectToString.call(/a/);
+
+module.exports = function (value) {
+	if (!value) return false;
+
+	// Sanity check (reject objects which do not expose common RegExp interface)
+	if (!hasOwnProperty.call(value, "lastIndex")) return false;
+	try {
+		if (typeof value.lastIndex !== "number") return false;
+		if (typeof value.test !== "function") return false;
+		if (typeof value.exec !== "function") return false;
+	} catch (error) {
+		return false;
+	}
+
+	// Ensure its native RegExp object (has [[RegExpMatcher]] slot)
+	if (isToStringTagSupported && typeof value[Symbol.toStringTag] === "string") {
+		// Edge case (possibly a regExp with custom Symbol.toStringTag)
+		try {
+			var lastIndex = value.lastIndex;
+			regExpTest.call(value, "");
+			if (value.lastIndex !== lastIndex) value.lastIndex = lastIndex;
+			return true;
+		} catch (error) {
+			return false;
+		}
+	}
+	if (objectToString.call(value) !== objectTaggedString) return false;
+	return !isPrototype(value);
+};

data/node_modules/type/safe-integer/coerce.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var coerceToInteger = require("../integer/coerce");
+
+var MAX_SAFE_INTEGER = 9007199254740991, MIN_SAFE_INTEGER = -9007199254740991;
+
+module.exports = function (value) {
+	value = coerceToInteger(value);
+	if (!value) return value;
+	if (value > MAX_SAFE_INTEGER) return null;
+	if (value < MIN_SAFE_INTEGER) return null;
+	return value;
+};

data/node_modules/type/safe-integer/ensure.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var resolveException = require("../lib/resolve-exception")
+  , coerce           = require("./coerce");
+
+module.exports = function (value/*, options*/) {
+	var coerced = coerce(value);
+	if (coerced !== null) return coerced;
+	return resolveException(value, "%v is not a safe integer", arguments[1]);
+};

data/node_modules/type/string/coerce.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var isValue  = require("../value/is")
+  , isObject = require("../object/is");
+
+var objectToString = Object.prototype.toString;
+
+module.exports = function (value) {
+	if (!isValue(value)) return null;
+	if (isObject(value)) {
+		// Reject Object.prototype.toString coercion
+		var valueToString = value.toString;
+		if (typeof valueToString !== "function") return null;
+		if (valueToString === objectToString) return null;
+		// Note: It can be object coming from other realm, still as there's no ES3 and CSP compliant
+		// way to resolve its realm's Object.prototype.toString it's left as not addressed edge case
+	}
+	try {
+		return "" + value; // Ensure implicit coercion
+	} catch (error) {
+		return null;
+	}
+};

data/node_modules/type/string/ensure.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var resolveException = require("../lib/resolve-exception")
+  , coerce           = require("./coerce");
+
+module.exports = function (value/*, options*/) {
+	var coerced = coerce(value);
+	if (coerced !== null) return coerced;
+	return resolveException(value, "%v is not a string", arguments[1]);
+};

data/node_modules/type/test/_lib/arrow-function-if-supported.js

@@ -0,0 +1,4 @@
+"use strict";
+
+try { module.exports = eval("(() => {})"); }
+catch (error) {}

data/node_modules/type/test/_lib/class-if-supported.js

@@ -0,0 +1,4 @@
+"use strict";
+
+try { module.exports = eval("(class {})"); }
+catch (error) {}

data/node_modules/type/test/array-length/coerce.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var assert              = require("chai").assert
+  , coerceToArrayLength = require("../../array-length/coerce");
+
+describe("array-length/coerce", function () {
+	it("Should coerce float", function () {
+		assert.equal(coerceToArrayLength(123.123), 123);
+		assert.equal(coerceToArrayLength(123.823), 123);
+	});
+	it("Should coerce string", function () { assert.equal(coerceToArrayLength("12.123"), 12); });
+	it("Should coerce booleans", function () { assert.equal(coerceToArrayLength(true), 1); });
+	it("Should coerce number objects", function () {
+		assert.equal(coerceToArrayLength(new Number(343)), 343);
+	});
+	it("Should coerce objects", function () {
+		assert.equal(coerceToArrayLength({ valueOf: function () { return 23; } }), 23);
+	});
+	it("Should reject infinite number", function () {
+		assert.equal(coerceToArrayLength(Infinity), null);
+	});
+	it("Should reject number beyond Number.MAX_SAFE_INTEGER", function () {
+		assert.equal(coerceToArrayLength(9007199254740992), null);
+	});
+	it("Should reject negative number", function () {
+		assert.equal(coerceToArrayLength(-9), null);
+	});
+
+	it("Should reject NaN", function () { assert.equal(coerceToArrayLength(NaN), null); });
+
+	if (typeof Object.create === "function") {
+		it("Should not coerce objects with no number representation", function () {
+			assert.equal(coerceToArrayLength(Object.create(null)), null);
+		});
+	}
+
+	it("Should not coerce null", function () { assert.equal(coerceToArrayLength(null), null); });
+	it("Should not coerce undefined", function () {
+		assert.equal(coerceToArrayLength(undefined), null);
+	});
+
+	if (typeof Symbol === "function") {
+		it("Should not coerce symbols", function () {
+			assert.equal(coerceToArrayLength(Symbol("foo")), null);
+		});
+	}
+});

data/node_modules/type/test/array-length/ensure.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var assert            = require("chai").assert
+  , ensureArrayLength = require("../../array-length/ensure");
+
+describe("array-length/ensure", function () {
+	it("Should return coerced value", function () {
+		assert.equal(ensureArrayLength("12.23"), 12);
+	});
+	it("Should crash on no value", function () {
+		try {
+			ensureArrayLength(-20);
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert.equal(error.message, "-20 is not a valid array length");
+		}
+	});
+});

data/node_modules/type/test/array-like/ensure.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var assert          = require("chai").assert
+  , ensureArrayLike = require("../../array-like/ensure");
+
+describe("array-like/ensure", function () {
+	it("Should return input value", function () {
+		var value = [];
+		assert.equal(ensureArrayLike(value), value);
+	});
+	it("Should allow strings with allowString option", function () {
+		var value = "foo";
+		assert.equal(ensureArrayLike(value, { allowString: true }), value);
+	});
+	it("Should crash on invalid value", function () {
+		try {
+			ensureArrayLike("foo");
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert(error.message.includes("is not an array like value"));
+		}
+	});
+});

data/node_modules/type/test/array-like/is.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var assert      = require("chai").assert
+  , isArrayLike = require("../../array-like/is");
+
+describe("array-like/is", function () {
+	it("Should return true on array", function () { assert.equal(isArrayLike([]), true); });
+	it("Should return true on array-like object", function () {
+		assert.equal(isArrayLike({ length: 1 }), true);
+	});
+	it("Should by default return false on string", function () {
+		assert.equal(isArrayLike("foo"), false);
+	});
+	it("Should accept strings if specified", function () {
+		assert.equal(isArrayLike("foo", { allowString: true }), true);
+	});
+
+	it("Should return false on objects with negative length", function () {
+		assert.equal(isArrayLike({ length: -1 }), false);
+	});
+
+	it("Should return false on plain object", function () {
+		assert.equal(isArrayLike({}), false);
+	});
+	it("Should return false on function", function () {
+		assert.equal(isArrayLike(function () { return true; }), false);
+	});
+
+	if (typeof Object.create === "function") {
+		it("Should return false on object with no prototype", function () {
+			assert.equal(isArrayLike(Object.create(null)), false);
+		});
+	}
+	it("Should return false on number", function () { assert.equal(isArrayLike(123), false); });
+	it("Should return false on NaN", function () { assert.equal(isArrayLike(NaN), false); });
+	it("Should return false on boolean", function () { assert.equal(isArrayLike(true), false); });
+	if (typeof Symbol === "function") {
+		it("Should return false on symbol", function () {
+			assert.equal(isArrayLike(Symbol("foo")), false);
+		});
+	}
+
+	it("Should return false on null", function () { assert.equal(isArrayLike(null), false); });
+	it("Should return false on undefined", function () {
+		assert.equal(isArrayLike(void 0), false);
+	});
+});

data/node_modules/type/test/array/ensure.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var assert      = require("chai").assert
+  , ensureArray = require("../../array/ensure");
+
+describe("array/ensure", function () {
+	it("Should return input value", function () {
+		var value = [];
+		assert.equal(ensureArray(value), value);
+	});
+	it("Should crash on invalid value", function () {
+		try {
+			ensureArray(null);
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert(error.message.includes("is not an array object"));
+		}
+	});
+});

data/node_modules/type/test/array/is.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var assert  = require("chai").assert
+  , isArray = require("../../array/is");
+
+describe("array/is", function () {
+	it("Should return true on array", function () { assert.equal(isArray([]), true); });
+
+	it("Should return false on array with no common API exposed", function () {
+		var value = [];
+		value.push = null;
+		assert.equal(isArray(value), false);
+	});
+	it("Should return false on Array.prototype", function () {
+		assert.equal(isArray(Array.prototype), false);
+	});
+
+	it("Should return false on plain object", function () { assert.equal(isArray({}), false); });
+	it("Should return false on function", function () {
+		assert.equal(isArray(function () { return true; }), false);
+	});
+
+	if (typeof Object.create === "function") {
+		it("Should return false on object with no prototype", function () {
+			assert.equal(isArray(Object.create(null)), false);
+		});
+	}
+	it("Should return false on string", function () { assert.equal(isArray("foo"), false); });
+	it("Should return false on empty string", function () { assert.equal(isArray(""), false); });
+	it("Should return false on number", function () { assert.equal(isArray(123), false); });
+	it("Should return false on NaN", function () { assert.equal(isArray(NaN), false); });
+	it("Should return false on boolean", function () { assert.equal(isArray(true), false); });
+	if (typeof Symbol === "function") {
+		it("Should return false on symbol", function () {
+			assert.equal(isArray(Symbol("foo")), false);
+		});
+	}
+
+	it("Should return false on null", function () { assert.equal(isArray(null), false); });
+	it("Should return false on undefined", function () { assert.equal(isArray(void 0), false); });
+});