orc-shared 5.10.0-dev.2 → 5.10.0-dev.21

package/src/utils/comparisonHelper.js

@@ -0,0 +1,135 @@
+import _ from "lodash";
+
+export const partialDeepEqual = (x, y, ignoredRootProps = null) => {
+	if (x == null || y == null) return x === y;
+
+	const keys = Object.keys(x);
+	if (!_.isEqual(keys, Object.keys(y))) {
+		return false;
+	}
+
+	for (let key of keys) {
+		if (ignoredRootProps && ignoredRootProps.includes(key)) {
+			continue;
+		}
+
+		if (!_.isEqual(x[key], y[key])) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+export const areGuidsEquals = (first, second) => {
+	function stripDash(value) {
+		return value?.replace(/-/g, "");
+	}
+
+	return areEqualCaseInsensitive(stripDash(first), stripDash(second));
+};
+
+export const areEqualCaseInsensitive = (first, second) => {
+	const isFirstNullish = first === null || first === undefined;
+	const isSecondNullish = second === null || second === undefined;
+
+	if (isFirstNullish || isSecondNullish) {
+		return isFirstNullish && isSecondNullish;
+	}
+
+	return first.localeCompare(second, undefined, { sensitivity: "accent" }) === 0;
+};
+
+const processOrderResult = (ascendingOrder, compareResult) => {
+	if (!ascendingOrder && compareResult != 0) {
+		return compareResult * -1;
+	}
+	return compareResult;
+};
+
+export const compareTextCaseInsensitive = (first, second, ascendingOrder = true, nullValue = "") => {
+	return processOrderResult(
+		ascendingOrder,
+		(first ?? nullValue).localeCompare(second ?? nullValue, undefined, { sensitivity: "accent" }),
+	);
+};
+
+export const getBooleanValue = value => {
+	let result = null;
+
+	if (typeof value === "string") {
+		if (areEqualCaseInsensitive(value, "true")) {
+			result = true;
+		} else if (areEqualCaseInsensitive(value, "false")) {
+			result = false;
+		}
+	} else if (typeof value === "boolean") {
+		result = value === true;
+	}
+
+	return result;
+};
+
+export const compareBoolean = (first, second) => {
+	const firstBool = getBooleanValue(first);
+	const secondBool = getBooleanValue(second);
+
+	if (firstBool === null && secondBool === null) {
+		return false;
+	}
+
+	return firstBool === secondBool;
+};
+
+export const compareNumeric = (first, second, ascendingOrder = true, nullValue = 0.0) => {
+	if (typeof first === "string" || first instanceof String || typeof second === "string" || second instanceof String) {
+		return processOrderResult(
+			ascendingOrder,
+			(first ?? nullValue.toString()).localeCompare(second ?? nullValue.toString(), undefined, {
+				numeric: true,
+			}),
+		);
+	}
+
+	let result = 0;
+	if ((first ?? nullValue) < (second ?? nullValue)) {
+		result = -1;
+	} else if ((first ?? nullValue) > (second ?? nullValue)) {
+		result = 1;
+	}
+
+	return processOrderResult(ascendingOrder, result);
+};
+
+export const doesObjectContainsTextCaseInsensitive = (obj, searchTerm, properties = []) => {
+	const caseInsensitiveIncludes = (a, b) => {
+		return a?.toLowerCase().includes(b);
+	};
+
+	if (!obj) {
+		return false;
+	}
+
+	if (searchTerm === null || searchTerm === undefined || searchTerm === "") {
+		return true;
+	}
+
+	const loweredSearchTerm = searchTerm.toLowerCase();
+	const propertiesToSearch = properties.length > 0 ? properties : Object.keys(obj);
+	const result =
+		propertiesToSearch.find(key => {
+			if (typeof obj[key] === "string") {
+				return caseInsensitiveIncludes(obj[key], loweredSearchTerm);
+			}
+
+			if (typeof obj[key] === "object" && obj[key]) {
+				const objectValues = Object.values(obj[key]);
+				return objectValues.find(
+					ovKey => typeof ovKey === "string" && caseInsensitiveIncludes(ovKey, loweredSearchTerm),
+				);
+			}
+
+			return false;
+		}) !== undefined;
+	return result;
+};

package/src/utils/comparisonHelper.test.js

@@ -0,0 +1,334 @@
+import {
+	areEqualCaseInsensitive,
+	areGuidsEquals,
+	doesObjectContainsTextCaseInsensitive,
+	partialDeepEqual,
+	compareTextCaseInsensitive,
+	compareNumeric,
+	compareBoolean,
+	getBooleanValue,
+} from "./comparisonHelper";
+
+describe("partialDeepEqual function", () => {
+	it.each([
+		["empty with non empty object", {}, { a: 1 }],
+		["different properties", { b: 2 }, { a: 1 }],
+		["same properties different values", { a: 2 }, { a: 1 }],
+		["same nested properties different values", { a: { b: 3 } }, { a: { b: 4 } }],
+	])("returns false if the objects are ", (msg, obj1, obj2) => {
+		const result = partialDeepEqual(obj1, obj2);
+		expect(result, "to equal", false);
+	});
+
+	it.each([
+		["empty objects", {}, {}],
+		["same properties", { a: 1 }, { a: 1 }],
+		["same nested properties same values", { a: { b: 3 } }, { a: { b: 3 } }],
+	])("returns true if the objects are ", (msg, obj1, obj2) => {
+		const result = partialDeepEqual(obj1, obj2);
+		expect(result, "to equal", true);
+	});
+
+	it("returns false even with ignored property", () => {
+		const obj1 = {
+			a: 2,
+			b: 1,
+		};
+
+		const obj2 = {
+			a: 1,
+			b: 1,
+		};
+
+		const result = partialDeepEqual(obj1, obj2, ["b"]);
+		expect(result, "to equal", false);
+	});
+
+	it("returns true with ignored property", () => {
+		const obj1 = {
+			a: 2,
+			b: 1,
+		};
+
+		const obj2 = {
+			a: 1,
+			b: 1,
+		};
+
+		const result = partialDeepEqual(obj1, obj2, ["a"]);
+		expect(result, "to equal", true);
+	});
+
+	it("returns true if both are null", () => {
+		const obj1 = null;
+
+		const obj2 = null;
+
+		const result = partialDeepEqual(obj1, obj2);
+		expect(result, "to equal", true);
+	});
+
+	it("returns true if both are undefined", () => {
+		const obj1 = undefined;
+
+		const obj2 = undefined;
+
+		const result = partialDeepEqual(obj1, obj2);
+		expect(result, "to equal", true);
+	});
+
+	it("returns true if one is null and the other undefined", () => {
+		const obj1 = null;
+
+		const obj2 = undefined;
+
+		const result = partialDeepEqual(obj1, obj2);
+		expect(result, "to equal", false);
+	});
+});
+
+describe("areGuidsEquals function", () => {
+	it.each([
+		[true, "AAA123", "aaa123"],
+		[true, "123", "1-2-3"],
+		[true, "1-2-3", "1-2-3"],
+		[true, "123", "123"],
+		[false, "123", "1-2-3-4"],
+		[false, "123", "1-2-3-4"],
+		[false, "123", null],
+		[false, "123", undefined],
+		[false, null, "123"],
+		[false, undefined, "123"],
+		[true, null, null],
+		[true, undefined, undefined],
+		[true, undefined, null],
+		[true, null, undefined],
+	])("returns %s for values %s and %s ", (expectedResult, value1, value2) => {
+		const result = areGuidsEquals(value1, value2);
+		expect(result, "to equal", expectedResult);
+	});
+});
+
+describe("areEqualCaseInsensitive function", () => {
+	it.each([
+		[true, "AAA123", "aaa123"],
+		[false, "123", "1-2-3"],
+		[true, "123", "123"],
+		[false, "123", null],
+		[false, "123", undefined],
+		[false, null, "123"],
+		[false, undefined, "123"],
+		[true, null, null],
+		[true, undefined, undefined],
+		[true, undefined, null],
+		[true, null, undefined],
+	])("returns %s for values %s and %s ", (expectedResult, value1, value2) => {
+		const result = areEqualCaseInsensitive(value1, value2);
+		expect(result, "to equal", expectedResult);
+	});
+});
+
+describe("getBooleanValue function", () => {
+	it.each([
+		[true, true],
+		[false, false],
+		["trUE", true],
+		["faLSe", false],
+		["faLSeInvalid", null],
+		["InvalidTrue", null],
+	])("value %s returned the result %s ", (value, expectedResult) => {
+		const result = getBooleanValue(value);
+		expect(result, "to equal", expectedResult);
+	});
+});
+
+describe("compareBoolean function", () => {
+	it.each([
+		[true, "tRuE", true],
+		[true, "tRuE1", false],
+		[true, "false", false],
+		[true, false, false],
+		["tRuE", true, true],
+		["tRuE1", true, false],
+		["false", true, false],
+		[true, true, true],
+		[false, true, false],
+		[false, "FaLSe", true],
+		[false, "FaLSe1", false],
+		[false, "TrUe", false],
+		["FaLSe", false, true],
+		["FaLSe1", false, false],
+		["TrUe", false, false],
+		[false, false, true],
+		[false, null, false],
+		["FaLSe", null, false],
+		[false, undefined, false],
+		["FaLSe", undefined, false],
+		["FaLSeInvalid", "TrueInvalid", false],
+	])("values %s and %s returned the result %s ", (value1, value2, expectedResult) => {
+		const result = compareBoolean(value1, value2);
+		expect(result, "to equal", expectedResult);
+	});
+});
+
+describe("doesObjectContainsTextCaseInsensitive function", () => {
+	it("returns false if object is null", function () {
+		const result = doesObjectContainsTextCaseInsensitive(null, "val");
+		expect(result, "to be", false);
+	});
+
+	it("returns false if object is undefined", function () {
+		const result = doesObjectContainsTextCaseInsensitive(undefined, "val");
+		expect(result, "to be", false);
+	});
+
+	it("returns true if searchTerm is null", function () {
+		const result = doesObjectContainsTextCaseInsensitive({}, null);
+		expect(result, "to be", true);
+	});
+
+	it("returns true if searchTerm is undefined", function () {
+		const result = doesObjectContainsTextCaseInsensitive({}, undefined);
+		expect(result, "to be", true);
+	});
+
+	it("returns true if searchTerm is an empty string", function () {
+		const result = doesObjectContainsTextCaseInsensitive({}, "");
+		expect(result, "to be", true);
+	});
+
+	it("returns false if object has no properties", function () {
+		const result = doesObjectContainsTextCaseInsensitive({}, "val");
+		expect(result, "to be", false);
+	});
+
+	it("returns false if text cannot be found in property", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: "another" }, "val");
+		expect(result, "to be", false);
+	});
+
+	it("returns true if text is found in property (exact match)", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: "another", prop2: "val" }, "val");
+		expect(result, "to be", true);
+	});
+
+	it("returns true if text is found in property (contains)", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: "another", prop2: "some value" }, "val");
+		expect(result, "to be", true);
+	});
+
+	it("returns true if text is found in property (case insensitive)", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: "another", prop2: "VALUE" }, "val");
+		expect(result, "to be", true);
+	});
+
+	it("ignores non string properties", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: 123, prop2: "VALUE" }, "val");
+		expect(result, "to be", true);
+	});
+
+	it("does look at second level properties of type string", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: { prop2: "VALUE" } }, "val");
+		expect(result, "to be", true);
+	});
+
+	it("does not look at second level properties of type number", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: { prop2: 123 } }, "val");
+		expect(result, "to be", false);
+	});
+
+	it("does not look at third level properties", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: { prop2: { prop3: "VALUE" } } }, "val");
+		expect(result, "to be", false);
+	});
+
+	it("does not crash if prop value is null", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: null, prop2: "bob" }, "val");
+		expect(result, "to be", false);
+	});
+
+	it("returns false because property with value is not looked at", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: "123", prop2: "VALUE" }, "val", ["prop"]);
+		expect(result, "to be", false);
+	});
+
+	it("returns true because property with value is looked at", function () {
+		const result = doesObjectContainsTextCaseInsensitive({ prop: "123", prop2: "VALUE" }, "val", ["prop2"]);
+		expect(result, "to be", true);
+	});
+});
+
+describe("compareTextCaseInsensitive function", () => {
+	it.each([
+		[0, "AAA123", "aaa123"],
+		[-1, "AAA123", "AAA1234"],
+		[-1, "123", "123a"],
+		[-1, null, "123"],
+		[-1, undefined, "123"],
+		[0, null, null],
+		[0, undefined, undefined],
+		[0, undefined, null],
+		[0, null, undefined],
+	])("returns %s for values %s and %s ", (expectedResult, value1, value2) => {
+		const result = compareTextCaseInsensitive(value1, value2);
+		expect(result, "to equal", expectedResult);
+	});
+
+	it.each([
+		[0, "AAA123", "aaa123"],
+		[1, "AAA123", "AAA1234"],
+		[1, "123", "123a"],
+		[1, null, "123"],
+		[1, undefined, "123"],
+		[0, null, null],
+		[0, undefined, undefined],
+		[0, undefined, null],
+		[0, null, undefined],
+	])("returns %s for values %s and %s for descending order", (expectedResult, value1, value2) => {
+		const result = compareTextCaseInsensitive(value1, value2, false);
+		expect(result, "to equal", expectedResult);
+	});
+});
+
+describe("compareNumeric function", () => {
+	it.each([
+		[0, 42, 42],
+		[-1, 42, 42.42],
+		[-1, null, 42],
+		[-1, undefined, 42],
+		[0, null, null],
+		[0, undefined, undefined],
+		[0, undefined, null],
+		[0, null, undefined],
+		[-1, "9", "42"],
+		[1, "9", null],
+		[1, "9", undefined],
+		[1, 9, 7],
+		[1, 9, undefined],
+		[1, undefined, -1],
+		[-1, null, "1"],
+		[-1, undefined, "1"],
+	])("returns %s for values %s and %s ", (expectedResult, value1, value2) => {
+		const result = compareNumeric(value1, value2);
+		expect(result, "to equal", expectedResult);
+	});
+
+	it.each([
+		[0, 42, 42],
+		[1, 42, 42.42],
+		[1, null, 42],
+		[1, undefined, 42],
+		[0, null, null],
+		[0, undefined, undefined],
+		[0, undefined, null],
+		[0, null, undefined],
+		[1, "9", "42"],
+		[-1, "9", null],
+		[-1, "9", undefined],
+		[1, null, "1"],
+		[1, undefined, "1"],
+	])("returns %s for values %s and %s for descending order", (expectedResult, value1, value2) => {
+		const result = compareNumeric(value1, value2, false);
+		expect(result, "to equal", expectedResult);
+	});
+});

package/src/utils/propertyBagHelper.js

@@ -20,6 +20,7 @@ export const customDataType = {
 	multipleCarrierProvidersSelector: "MultipleCarrierProvidersSelector",
 	serviceLevelSelector: "ServiceLevelSelector",
 	percentageDecimal: "PercentageDecimal",
+	carrierReferenceFieldSelector: "CarrierReferenceFieldSelector",
 };
 
 const tieredAttributeTypes = [customDataType.priceTieredRateTable, customDataType.quantityTieredRateTable];
@@ -84,6 +85,7 @@ export const toJsonCargo = (attribute, value) => {
 				case customDataType.routingProviderSelector:
 				case customDataType.multipleCarrierProvidersSelector:
 				case customDataType.serviceLevelSelector:
+				case customDataType.carrierReferenceFieldSelector:
 					return value;
 				default:
 					throw new Error(`toJsonCargo: attribute.customDataType ${attribute.customDataType} is not implemented`);

package/src/utils/propertyBagHelper.test.js

@@ -48,6 +48,12 @@ describe("toJsonCargo function", () => {
 	it.each([
 		["aTextValue", attributeDataType.text, null, "aTextValue"],
 		["aPassword", attributeDataType.customType, customDataType.password, "aPassword"],
+		[
+			"aCarrierReferenceFieldSelector",
+			attributeDataType.customType,
+			customDataType.carrierReferenceFieldSelector,
+			"aCarrierReferenceFieldSelector",
+		],
 		[
 			"aCarrierProviderSelector",
 			attributeDataType.customType,

package/src/utils/timezoneHelper.js

@@ -1,19 +1,19 @@
 import moment from "moment-timezone";
 
-export const getTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
+const timeZonesList = require("../timezones.json");
 
-export const getTimeZoneByName = name => {
-	for (let [key, value] of timeZonesList.entries()) {
-		if (value === name) return key;
-	}
+export const getIanaTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
 
-	return getTimeZone();
+export const getIanaTimeZoneFromWindowsName = windowsName => {
+	// If not found, the mapping might need to be updated, rerun the generateWindowsZone script
+	return (timeZonesList.windowsToIana[windowsName] ?? [getIanaTimeZone()])[0];
 };
 
-export const getTimeZoneName = () => {
-	const customerTimezone = getTimeZone();
-	const timezoneName = timeZonesList.get(customerTimezone);
-	return timezoneName;
+export const getWindowsTimeZone = () => {
+	const customerTimezone = getIanaTimeZone();
+	const windowsTimezones = timeZonesList.ianaToWindows[customerTimezone];
+	// If not found, the mapping might need to be updated, rerun the generateWindowsZone script
+	return (windowsTimezones ?? [customerTimezone])[0];
 };
 
 //converting time from other timezone to local
@@ -31,128 +31,3 @@ export const convertTimeToOtherTimeZone = (date, timezone) => {
 	const dateWithOtherZone = [dateWithoutZone, otherZone].join("");
 	return new Date(dateWithOtherZone);
 };
-
-export const timeZonesList = new Map([
-	["Africa/Bangui", "W. Central Africa Standard Time"],
-	["Africa/Cairo", "Egypt Standard Time"],
-	["Africa/Casablanca", "Morocco Standard Time"],
-	["Africa/Harare", "South Africa Standard Time"],
-	["Africa/Johannesburg", "South Africa Standard Time"],
-	["Africa/Lagos", "W. Central Africa Standard Time"],
-	["Africa/Monrovia", "Greenwich Standard Time"],
-	["Africa/Nairobi", "E. Africa Standard Time"],
-	["Africa/Windhoek", "Namibia Standard Time"],
-	["America/Anchorage", "Alaskan Standard Time"],
-	["America/Argentina/San_Juan", "Argentina Standard Time"],
-	["America/Asuncion", "Paraguay Standard Time"],
-	["America/Bahia", "Bahia Standard Time"],
-	["America/Bogota", "SA Pacific Standard Time"],
-	["America/Buenos_Aires", "Argentina Standard Time"],
-	["America/Caracas", "Venezuela Standard Time"],
-	["America/Cayenne", "SA Eastern Standard Time"],
-	["America/Chicago", "Central Standard Time"],
-	["America/Chihuahua", "Mountain Standard Time (Mexico)"],
-	["America/Cuiaba", "Central Brazilian Standard Time"],
-	["America/Denver", "Mountain Standard Time"],
-	["America/Fortaleza", "SA Eastern Standard Time"],
-	["America/Godthab", "Greenland Standard Time"],
-	["America/Guatemala", "Central America Standard Time"],
-	["America/Halifax", "Atlantic Standard Time"],
-	["America/Indianapolis", "US Eastern Standard Time"],
-	["America/Indiana/Indianapolis", "US Eastern Standard Time"],
-	["America/La_Paz", "SA Western Standard Time"],
-	["America/Los_Angeles", "Pacific Standard Time"],
-	["America/Mexico_City", "Mexico Standard Time"],
-	["America/Montevideo", "Montevideo Standard Time"],
-	["America/New_York", "Eastern Standard Time"],
-	["America/Noronha", "UTC-02"],
-	["America/Phoenix", "US Mountain Standard Time"],
-	["America/Regina", "Canada Central Standard Time"],
-	["America/Santa_Isabel", "Pacific Standard Time (Mexico)"],
-	["America/Santiago", "Pacific SA Standard Time"],
-	["America/Sao_Paulo", "E. South America Standard Time"],
-	["America/St_Johns", "Newfoundland Standard Time"],
-	["America/Tijuana", "Pacific Standard Time"],
-	["Antarctica/McMurdo", "New Zealand Standard Time"],
-	["Atlantic/South_Georgia", "UTC-02"],
-	["Asia/Almaty", "Central Asia Standard Time"],
-	["Asia/Amman", "Jordan Standard Time"],
-	["Asia/Baghdad", "Arabic Standard Time"],
-	["Asia/Baku", "Azerbaijan Standard Time"],
-	["Asia/Bangkok", "SE Asia Standard Time"],
-	["Asia/Beirut", "Middle East Standard Time"],
-	["Asia/Calcutta", "India Standard Time"],
-	["Asia/Colombo", "Sri Lanka Standard Time"],
-	["Asia/Damascus", "Syria Standard Time"],
-	["Asia/Dhaka", "Bangladesh Standard Time"],
-	["Asia/Dubai", "Arabian Standard Time"],
-	["Asia/Irkutsk", "North Asia East Standard Time"],
-	["Asia/Jerusalem", "Israel Standard Time"],
-	["Asia/Kabul", "Afghanistan Standard Time"],
-	["Asia/Kamchatka", "Kamchatka Standard Time"],
-	["Asia/Karachi", "Pakistan Standard Time"],
-	["Asia/Katmandu", "Nepal Standard Time"],
-	["Asia/Kolkata", "India Standard Time"],
-	["Asia/Krasnoyarsk", "North Asia Standard Time"],
-	["Asia/Kuala_Lumpur", "Singapore Standard Time"],
-	["Asia/Kuwait", "Arab Standard Time"],
-	["Asia/Magadan", "Magadan Standard Time"],
-	["Asia/Muscat", "Arabian Standard Time"],
-	["Asia/Novosibirsk", "N. Central Asia Standard Time"],
-	["Asia/Oral", "West Asia Standard Time"],
-	["Asia/Rangoon", "Myanmar Standard Time"],
-	["Asia/Riyadh", "Arab Standard Time"],
-	["Asia/Seoul", "Korea Standard Time"],
-	["Asia/Shanghai", "China Standard Time"],
-	["Asia/Singapore", "Singapore Standard Time"],
-	["Asia/Taipei", "Taipei Standard Time"],
-	["Asia/Tashkent", "West Asia Standard Time"],
-	["Asia/Tbilisi", "Georgian Standard Time"],
-	["Asia/Tehran", "Iran Standard Time"],
-	["Asia/Tokyo", "Tokyo Standard Time"],
-	["Asia/Ulaanbaatar", "Ulaanbaatar Standard Time"],
-	["Asia/Vladivostok", "Vladivostok Standard Time"],
-	["Asia/Yakutsk", "Yakutsk Standard Time"],
-	["Asia/Yekaterinburg", "Ekaterinburg Standard Time"],
-	["Asia/Yerevan", "Armenian Standard Time"],
-	["Atlantic/Azores", "Azores Standard Time"],
-	["Atlantic/Cape_Verde", "Cape Verde Standard Time"],
-	["Atlantic/Reykjavik", "Greenwich Standard Time"],
-	["Australia/Adelaide", "Cen. Australia Standard Time"],
-	["Australia/Brisbane", "E. Australia Standard Time"],
-	["Australia/Darwin", "AUS Central Standard Time"],
-	["Australia/Hobart", "Tasmania Standard Time"],
-	["Australia/Perth", "W. Australia Standard Time"],
-	["Australia/Sydney", "AUS Eastern Standard Time"],
-	["UTC", "UTC"],
-	["Etc/GMT+11", "UTC-11"],
-	["Etc/GMT+12", "Dateline Standard Time"],
-	["Etc/GMT+2", "UTC-02"],
-	["Etc/GMT-12", "UTC+12"],
-	["Europe/Amsterdam", "W. Europe Standard Time"],
-	["Europe/Athens", "GTB Standard Time"],
-	["Europe/Belgrade", "Central Europe Standard Time"],
-	["Europe/Berlin", "W. Europe Standard Time"],
-	["Europe/Brussels", "Romance Standard Time"],
-	["Europe/Budapest", "Central Europe Standard Time"],
-	["Europe/Dublin", "GMT Standard Time"],
-	["Europe/Helsinki", "FLE Standard Time"],
-	["Europe/Istanbul", "GTB Standard Time"],
-	["Europe/Kiev", "FLE Standard Time"],
-	["Europe/London", "GMT Standard Time"],
-	["Europe/Minsk", "E. Europe Standard Time"],
-	["Europe/Moscow", "Russian Standard Time"],
-	["Europe/Paris", "Romance Standard Time"],
-	["Europe/Sarajevo", "Central European Standard Time"],
-	["Europe/Warsaw", "Central European Standard Time"],
-	["Indian/Mauritius", "Mauritius Standard Time"],
-	["Pacific/Apia", "Samoa Standard Time"],
-	["Pacific/Auckland", "New Zealand Standard Time"],
-	["Pacific/Fiji", "Fiji Standard Time"],
-	["Pacific/Guadalcanal", "Central Pacific Standard Time"],
-	["Pacific/Guam", "West Pacific Standard Time"],
-	["Pacific/Honolulu", "Hawaiian Standard Time"],
-	["Pacific/Pago_Pago", "UTC-11"],
-	["Pacific/Port_Moresby", "West Pacific Standard Time"],
-	["Pacific/Tongatapu", "Tonga Standard Time"],
-]);