Phase 1 PWA: prayer times, qibla, quran, hijri, tasbih, 99 names

node_modules/own-keys/index.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var callBound = require('call-bound');
+var safePushApply = require('safe-push-apply');
+
+var $ownKeys = GetIntrinsic('%Reflect.ownKeys%', true);
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
+var $gOPS = GetIntrinsic('%Object.getOwnPropertySymbols%', true);
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+var keys = require('object-keys');
+
+// eslint-disable-next-line array-bracket-newline
+var order = ['b', 'd', 'a', 'c', 'g', 'e', 'h', 'f', 'j', 'i', 'l', 'k'];
+/*
+ * Some pre-ES2015 engines (notably V8 in node 0.8) enumerate own property names
+ * in a per-realm randomized order rather than property-creation order, and a
+ * `Reflect.ownKeys`/`getOwnPropertyNames` shim layered on top (e.g. es6-shim)
+ * inherits that. `Object.keys` is ordered even there, so probe whichever key
+ * source we're about to use and reconstruct from `object-keys` when it can't be
+ * trusted to preserve insertion order.
+ */
+/** @param {(o: object) => (string | symbol)[]} getNames */
+function preservesInsertionOrder(getNames) {
+	/** @type {Record<string, boolean>} */
+	var probe = {};
+	var got;
+	var i;
+	for (i = 0; i < order.length; i += 1) {
+		probe[order[i]] = true;
+	}
+	got = getNames(probe);
+	if (got.length !== order.length) {
+		return false;
+	}
+	for (i = 0; i < order.length; i += 1) {
+		if (got[i] !== order[i]) {
+			return false;
+		}
+	}
+	return true;
+}
+
+var nativeOwnKeys = $ownKeys && preservesInsertionOrder($ownKeys) ? $ownKeys : null;
+var trustGOPNOrder = !nativeOwnKeys && $gOPN && preservesInsertionOrder($gOPN);
+
+/** @type {typeof import('.')} */
+module.exports = nativeOwnKeys || function ownKeys(source) {
+	/** @type {(keyof typeof source)[]} */
+	var sourceKeys;
+	var allNames;
+	var name;
+	var i;
+
+	if ($gOPN && trustGOPNOrder) {
+		sourceKeys = $gOPN(source);
+	} else {
+		/*
+		 * The available key source can't be trusted to preserve order, so take the
+		 * enumerable keys from `object-keys` (ordered) and borrow only the
+		 * non-enumerable names from `getOwnPropertyNames` (their relative order is
+		 * unrecoverable on such engines).
+		 */
+		sourceKeys = keys(source);
+		if ($gOPN) {
+			allNames = $gOPN(source);
+			for (i = 0; i < allNames.length; i += 1) {
+				name = allNames[i];
+				if (!$isEnumerable(source, name)) {
+					sourceKeys[sourceKeys.length] = name;
+				}
+			}
+		}
+	}
+	if ($gOPS) {
+		safePushApply(sourceKeys, $gOPS(source));
+	}
+	return sourceKeys;
+};