@dbmx/confy 0.0.72 → 0.0.76

package/esm/node_modules/@dbmx/users/esm/index.js

@@ -0,0 +1,251 @@
+import roles from './roles.js';
+import curry from './node_modules/ramda/es/curry.js';
+import is from './node_modules/ramda/es/is.js';
+import difference from './node_modules/ramda/es/difference.js';
+import intersection from './node_modules/ramda/es/intersection.js';
+import includes from './node_modules/ramda/es/includes.js';
+import map from './node_modules/ramda/es/map.js';
+import either from './node_modules/ramda/es/either.js';
+import prop from './node_modules/ramda/es/prop.js';
+import identity from './node_modules/ramda/es/identity.js';
+import propEq from './node_modules/ramda/es/propEq.js';
+
+const ROLES = roles;
+
+const hroles = ROLES.reduce((acc, role) => {
+  acc[role.id] = role;
+  return acc
+}, {});
+
+/**
+ * Checks if a user has all specified roles
+ * @function hasAllRoles
+ * @tag users
+ * @param {Array|string} - Roles to check
+ * @param {Object} - User object containing roles
+ * @return {boolean} - Returns true if the user has all specified roles, otherwise false
+ * @example
+ *
+ *   expect(hasAllRoles(['a', 'b'], { roles: ['a', 'b', 'c'] })).toBeTruthy()
+ *   expect(hasAllRoles(['a', 'b'], { roles: ['a', 'd'] })).toBeFalsy()
+ *
+ */
+const hasAllRoles = curry((roles, user) => {
+  if (!user) return false
+  const mustHave = is(Array, roles) ? roles : [roles];
+  return !difference(mustHave, user.roles || []).length
+});
+
+/**
+ * Alias for `hasAllRoles`
+ * @function hasRole
+ */
+const hasRole = hasAllRoles;
+
+/**
+ * Checks if a user is an administrator
+ * @function isAdmin
+ * @tag users
+ * @param {Object} - User object containing roles
+ * @return {boolean} - Returns true if the user is an administrator, otherwise false
+ * @example
+ *
+ *   expect(isAdmin({ roles: ['admin'] })).toBeTruthy()
+ *   expect(isAdmin({ roles: ['admin', 'toto'] })).toBeTruthy()
+ *   expect(isAdmin({ roles: ['titi', 'toto'] })).toBeFalsy()
+ *
+ */
+const isAdmin = hasRole('admin');
+
+/**
+ * Checks if a user has some of the specified roles
+ * @function hasSomeRole
+ * @tag users
+ * @param {Array|string} - Roles to check
+ * @param {Object} - User object containing roles
+ * @return {boolean} - Returns true if the user has some of the specified roles, otherwise false
+ * @example
+ *
+ *   expect(hasSomeRoles(['a', 'b'], { roles: ['a'] })).toBeTruthy()
+ *   expect(hasSomeRoles(['a', 'b'], { roles: ['c', 'd'] })).toBeFalsy()
+ *
+ */
+curry((roles, user) => {
+  if (!user) return false
+  const some = is(Array, roles) ? roles : [roles];
+  return intersection(some, user.roles || []).length
+});
+
+/**
+ * Checks if a user has a root role
+ * @function hasRootRole
+ * @tag users
+ * @param {string} - Root role to check
+ * @param {Object} - User object containing roles
+ * @return {boolean} - Returns true if the user has the root role, otherwise false
+ * @example
+ *
+ *   expect(hasRootRole('a:b', { roles: ['a:b:c', '1:2'] })).toBeTruthy()
+ *   expect(hasRootRole('a:b', { roles: ['1:a:b:c', '1:2'] })).toBeFalsy()
+ *
+ */
+curry((role, user) => {
+  if (!user) return false
+  for (const userRole of user.roles || []) {
+    if (userRole.startsWith(role)) return true
+  }
+  return false
+});
+
+/**
+ * Checks if a user has the specified permission
+ * @function hasPermission
+ * @tag users
+ * @param {string} - Permission to check
+ * @param {Object} - User object containing roles and permissions
+ * @return {boolean} - Returns true if the user has all specified permissions, otherwise false
+ * @example
+ *
+ *   expect(hasPermission('sxs:spaces:read', { roles: ['sxs:spaces:editor'] })).toBeTruthy()
+ *   expect(hasPermission('sxs:spaces:*', { roles: ['sxs:spaces:editor'] })).toBeTruthy()
+ *   expect(hasPermission('jobs:viewer', { roles: ['sxs:spaces:editor'] })).toBeFalsy()
+ *
+ */
+
+const hasPermission = (permission, user) => {
+  if (!permission || !user) return false
+  if (isAdmin(user)) return true
+  const idx = permission.indexOf('*');
+  const permissions = [];
+  for (const permission of getRolesPermissions(user.roles)) permissions.push(permission);
+  if (idx !== -1) {
+    const regexp = new RegExp(`^${permission.slice(0, idx)}`);
+    for (const permission of permissions) {
+      if (regexp.test(permission)) return true
+    }
+    return false
+  } else {
+    return permissions?.includes(permission)
+  }
+};
+
+/**
+ * Checks if a user has all specified permissions
+ * @function hasPermissions
+ * @tag users
+ * @param {Array|string} - Permissions to check
+ * @param {Object} - User object containing roles and permissions
+ * @return {boolean} - Returns true if the user has all specified permissions, otherwise false
+ * @example
+ *
+ *   expect(hasPermissions(['jobs*'], { roles: ['sxs:spaces:editor'] })).toBeFalsy()
+ *   expect(hasPermissions('a:b', { roles: ['admin'] })).toBeTruthy()
+ *
+ */
+const hasPermissions = (permissions, user) => {
+  if (!permissions || !user) return false
+  if (isAdmin(user)) return true
+  const some = is(Array, permissions) ? permissions : [permissions];
+  for (const permission of some) {
+    if (!hasPermission(permission, user)) return false
+  }
+  return true
+};
+
+/**
+ * Checks if a user is a member
+ * @function hasMember
+ * @tag users
+ * @param {string} - Member ID to check
+ * @param {Object} - User object containing member information
+ * @return {boolean} - Returns true if the user is a member, otherwise false
+ * @example
+ *
+ *   expect(hasMember('toto', { members: ['toto', 'titi'] })).toBeTruthy()
+ *   expect(hasMember('toto', { roles: ['admin'] })).toBeTruthy()
+ *   expect(hasMember('tot', { members: ['toto', 'titi'] })).toBeFalsy()
+ *
+ */
+curry((member, user) => {
+  if (!user) return false
+  if (isAdmin(user)) return true
+  const memberIds = getMemberIds(user);
+  return includes(member, memberIds)
+});
+
+const getMemberIds = user => {
+  if (!user || isAdmin(user)) return
+  return map(either(prop('id'), identity), user.members || [])
+};
+
+const STATUS = {
+  active: 'active',
+  inactive: 'inactive',
+  pending: 'pending',
+};
+
+/**
+ * Checks if a user is active
+ * @function isActive
+ * @tag users
+ * @param {Object} - User object containing status information
+ * @return {boolean} - Returns true if the user is active, otherwise false
+ * @example
+ *
+ * isActive({status: 'active'}) // true
+ * isActive({status: 'inactive'}) //false
+ * isActive({status: 'pending'}) //false
+ *
+ */
+propEq('status', STATUS.active);
+
+/**
+ * Checks if a user is inactive
+ * @function isInActive
+ * @tag users
+ * @param {Object} - User object containing status information
+ * @return {boolean} - Returns true if the user is inactive, otherwise false
+ * @example
+ *
+ * isActive({status: 'active'}) // false
+ * isActive({status: 'inactive'}) //true
+ * isActive({status: 'pending'}) //false
+ *
+ */
+propEq('status', STATUS.inactive);
+
+/**
+ * Checks if a user is pending
+ * @function isPending
+ * @tag users
+ * @param {Object} - User object containing status information
+ * @return {boolean} - Returns true if the user is pending, otherwise false
+ * @example
+ *
+ * isActive({status: 'active'}) // false
+ * isActive({status: 'inactive'}) //false
+ * isActive({status: 'pending'}) //true
+ *
+ */
+propEq('status', STATUS.pending);
+
+/**
+ * Retrieves permissions from user roles
+ * @function getRolesPermissions
+ * @tag users
+ * @param {Array|string} - User roles
+ * @return {Array} - Array of permissions
+ */
+const getRolesPermissions = roles => {
+  if (!roles) return []
+  const permissions = [];
+  for (const role of is(Array, roles) ? roles : [roles]) {
+    for (const permission of hroles[role]?.permissions || []) {
+      permissions.push(permission);
+    }
+  }
+  return permissions
+};
+
+export { ROLES, STATUS, getMemberIds, getRolesPermissions, hasAllRoles, hasPermission, hasPermissions, hasRole, isAdmin };
+//# sourceMappingURL=index.js.map

package/esm/node_modules/@dbmx/users/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/@dbmx/users/esm/index.mjs"],"sourcesContent":["import roles from './roles.mjs';\nimport curry from './node_modules/ramda/es/curry.mjs';\nimport is from './node_modules/ramda/es/is.mjs';\nimport difference from './node_modules/ramda/es/difference.mjs';\nimport intersection from './node_modules/ramda/es/intersection.mjs';\nimport includes from './node_modules/ramda/es/includes.mjs';\nimport map from './node_modules/ramda/es/map.mjs';\nimport either from './node_modules/ramda/es/either.mjs';\nimport prop from './node_modules/ramda/es/prop.mjs';\nimport identity from './node_modules/ramda/es/identity.mjs';\nimport propEq from './node_modules/ramda/es/propEq.mjs';\n\nconst ROLES = roles;\n\nconst hroles = ROLES.reduce((acc, role) => {\n  acc[role.id] = role;\n  return acc\n}, {});\n\n/**\n * Checks if a user has all specified roles\n * @function hasAllRoles\n * @tag users\n * @param {Array|string} - Roles to check\n * @param {Object} - User object containing roles\n * @return {boolean} - Returns true if the user has all specified roles, otherwise false\n * @example\n *\n *   expect(hasAllRoles(['a', 'b'], { roles: ['a', 'b', 'c'] })).toBeTruthy()\n *   expect(hasAllRoles(['a', 'b'], { roles: ['a', 'd'] })).toBeFalsy()\n *\n */\nconst hasAllRoles = curry((roles, user) => {\n  if (!user) return false\n  const mustHave = is(Array, roles) ? roles : [roles];\n  return !difference(mustHave, user.roles || []).length\n});\n\n/**\n * Alias for `hasAllRoles`\n * @function hasRole\n */\nconst hasRole = hasAllRoles;\n\n/**\n * Alias for `hasAllRoles`\n * @function hasRoles\n */\nconst hasRoles = hasAllRoles;\n\n/**\n * Checks if a user is an administrator\n * @function isAdmin\n * @tag users\n * @param {Object} - User object containing roles\n * @return {boolean} - Returns true if the user is an administrator, otherwise false\n * @example\n *\n *   expect(isAdmin({ roles: ['admin'] })).toBeTruthy()\n *   expect(isAdmin({ roles: ['admin', 'toto'] })).toBeTruthy()\n *   expect(isAdmin({ roles: ['titi', 'toto'] })).toBeFalsy()\n *\n */\nconst isAdmin = hasRole('admin');\n\n/**\n * Checks if a user has some of the specified roles\n * @function hasSomeRole\n * @tag users\n * @param {Array|string} - Roles to check\n * @param {Object} - User object containing roles\n * @return {boolean} - Returns true if the user has some of the specified roles, otherwise false\n * @example\n *\n *   expect(hasSomeRoles(['a', 'b'], { roles: ['a'] })).toBeTruthy()\n *   expect(hasSomeRoles(['a', 'b'], { roles: ['c', 'd'] })).toBeFalsy()\n *\n */\nconst hasSomeRoles = curry((roles, user) => {\n  if (!user) return false\n  const some = is(Array, roles) ? roles : [roles];\n  return intersection(some, user.roles || []).length\n});\n\n/**\n * Checks if a user has a root role\n * @function hasRootRole\n * @tag users\n * @param {string} - Root role to check\n * @param {Object} - User object containing roles\n * @return {boolean} - Returns true if the user has the root role, otherwise false\n * @example\n *\n *   expect(hasRootRole('a:b', { roles: ['a:b:c', '1:2'] })).toBeTruthy()\n *   expect(hasRootRole('a:b', { roles: ['1:a:b:c', '1:2'] })).toBeFalsy()\n *\n */\nconst hasRootRole = curry((role, user) => {\n  if (!user) return false\n  for (const userRole of user.roles || []) {\n    if (userRole.startsWith(role)) return true\n  }\n  return false\n});\n\n/**\n * Checks if a user can wrte on artefacts linked to all specified agencies\n * @function hasAgencies\n * @tag users\n * @param {Array|string} - Agency Ids to check\n * @param {string|{id}} - Member ID\n * @param {Object} - User object containing members and related agencies\n * @return {boolean} - Returns true if the user has all specified agencyIds, otherwise false\n * @example\n *\n *   const user = {\n       members: [{ id: 'member1', agencies: [{ id: 'AGENCY1' }, { id: 'AGENCY2' }] }],\n     }\n\n *   expect(hasAgencies(['AGENCY1', 'AGENCY2'], 'unknownMember', user)).toBeFalsy()\n *   expect(hasAgencies('AGENCY1', 'member1', user)).toBeTruthy()\n *   expect(hasAgencies('AGENCY2', 'member1', user)).toBeTruthy()\n * \n *   expect(hasAgencies('AGENCY1.FSD', 'member1', user)).toBeTruthy()\n *   expect(hasAgencies(['AGENCY1','AGENCY1.FSD'], 'member1', user)).toBeTruthy()\n * \n *   expect(hasAgencies(['AGENCY1', 'AGENCY2'], 'member1', user)).toBeTruthy() \n *   expect(hasAgencies(['AGENCY1', 'AGENCY2', 'unknownAgencyId'], 'member1', user)).toBeFalsy() \n *   expect(hasAgencies('unknownAgencyId', 'member1', user)).toBeFalsy() \n *\n */\nconst hasAgencies = (agencyIds, memberId, user) => {\n  if (!agencyIds || !memberId || !user) return false\n  if (isAdmin(user)) return true\n  if (!user.members?.length) return false\n\n  agencyIds = Array.isArray(agencyIds) ? agencyIds : [agencyIds];\n  if (memberId.id) memberId = memberId.id;\n\n  const userMember = user.members.find(member => member.id === memberId);\n  if (!userMember?.agencies) return true\n  if (!userMember.agencies.length) return false\n\n  const userAgencyIds = map(prop('id'), userMember.agencies);\n\n  for (const agencyId of agencyIds) {\n    const hasAccess = userAgencyIds.some(\n      userAgencyId => agencyId === userAgencyId || agencyId.startsWith(`${userAgencyId}.`),\n    );\n    if (!hasAccess) return false\n  }\n\n  return true\n};\n\n/**\n * Returns a list of writable agencies\n * @function getWritableAgencies\n * @tag users\n * @param {Array} - Agency List\n * @param {string} - Member ID\n * @param {Object} - User object containing members and related agencies\n * @return {Array} - Returns the list of writable agencies for the specified memberId and the specified user\n * @example\n *\n *   const user = {\n *     members: [\n *       {\n *         id: 'member1',\n *         agencies: [{ id: 'FSD' }],\n *       },\n *       {\n *         id: 'member2',\n *         agencies: [{ id: 'SDMX' }],\n *       },\n *       {\n *         id: 'member3',\n *         agencies: [{ id: 'ORG' }],\n *       },\n *     ],\n *   }\n *\n *   const agencyList = [\n *     { id: 'FSD', name: 'FSD' },\n *     { id: 'SDMX', name: 'SDMX' },\n *     { id: 'ORG', name: 'ORG' },\n *     { id: 'ORG.TEST1', name: 'TEST1' },\n *     { id: 'ORG.TEST2', name: 'TEST2' },\n *   ]\n *\n *   expect(getWritableAgencies(agencyList, 'member1', { roles: ['admin'] })).toStrictEqual(agencyList)\n *   expect(getWritableAgencies(agencyList, 'member1', user)).toStrictEqual([{ id: 'FSD', name: 'FSD' }])\n *   expect(getWritableAgencies(agencyList, 'member2', user)).toStrictEqual([{ id: 'SDMX', name: 'SDMX' }])\n *   expect(getWritableAgencies(agencyList, 'member3', user)).toStrictEqual([{ id: 'ORG', name: 'ORG' }, { id: 'ORG.TEST1', name: 'TEST1' }, { id: 'ORG.TEST2', name: 'TEST2' }])\n *\n */\nconst getWritableAgencies = (agencyList, memberId, user) => {\n  if (!agencyList?.length || !memberId || !user) return []\n  if (isAdmin(user)) return agencyList\n  if (!user.members?.length) return []\n\n  if (memberId.id) memberId = memberId.id;\n\n  const userMember = user.members.find(member => member.id === memberId);\n  if (!userMember?.agencies) return agencyList\n  if (!userMember.agencies.length) return []\n\n  const userAgencyIds = map(prop('id'), userMember.agencies);\n\n  return agencyList.filter(agency =>\n    userAgencyIds.some(userAgencyId => {\n      const agencyId = agency.agencyID ?? agency.id;\n      if (!agencyId) return false\n\n      return agencyId.startsWith(userAgencyId)\n    }),\n  )\n};\n\n/**\n * Checks if a user has the specified permission\n * @function hasPermission\n * @tag users\n * @param {string} - Permission to check\n * @param {Object} - User object containing roles and permissions\n * @return {boolean} - Returns true if the user has all specified permissions, otherwise false\n * @example\n *\n *   expect(hasPermission('sxs:spaces:read', { roles: ['sxs:spaces:editor'] })).toBeTruthy()\n *   expect(hasPermission('sxs:spaces:*', { roles: ['sxs:spaces:editor'] })).toBeTruthy()\n *   expect(hasPermission('jobs:viewer', { roles: ['sxs:spaces:editor'] })).toBeFalsy()\n *\n */\n\nconst hasPermission = (permission, user) => {\n  if (!permission || !user) return false\n  if (isAdmin(user)) return true\n  const idx = permission.indexOf('*');\n  const permissions = [];\n  for (const permission of getRolesPermissions(user.roles)) permissions.push(permission);\n  if (idx !== -1) {\n    const regexp = new RegExp(`^${permission.slice(0, idx)}`);\n    for (const permission of permissions) {\n      if (regexp.test(permission)) return true\n    }\n    return false\n  } else {\n    return permissions?.includes(permission)\n  }\n};\n\n/**\n * Checks if a user has all specified permissions\n * @function hasPermissions\n * @tag users\n * @param {Array|string} - Permissions to check\n * @param {Object} - User object containing roles and permissions\n * @return {boolean} - Returns true if the user has all specified permissions, otherwise false\n * @example\n *\n *   expect(hasPermissions(['jobs*'], { roles: ['sxs:spaces:editor'] })).toBeFalsy()\n *   expect(hasPermissions('a:b', { roles: ['admin'] })).toBeTruthy()\n *\n */\nconst hasPermissions = (permissions, user) => {\n  if (!permissions || !user) return false\n  if (isAdmin(user)) return true\n  const some = is(Array, permissions) ? permissions : [permissions];\n  for (const permission of some) {\n    if (!hasPermission(permission, user)) return false\n  }\n  return true\n};\n\n/**\n * Checks if a user is a member\n * @function hasMember\n * @tag users\n * @param {string} - Member ID to check\n * @param {Object} - User object containing member information\n * @return {boolean} - Returns true if the user is a member, otherwise false\n * @example\n *\n *   expect(hasMember('toto', { members: ['toto', 'titi'] })).toBeTruthy()\n *   expect(hasMember('toto', { roles: ['admin'] })).toBeTruthy()\n *   expect(hasMember('tot', { members: ['toto', 'titi'] })).toBeFalsy()\n *\n */\nconst hasMember = curry((member, user) => {\n  if (!user) return false\n  if (isAdmin(user)) return true\n  const memberIds = getMemberIds(user);\n  return includes(member, memberIds)\n});\n\nconst getMemberIds = user => {\n  if (!user || isAdmin(user)) return\n  return map(either(prop('id'), identity), user.members || [])\n};\n\nconst STATUS = {\n  active: 'active',\n  inactive: 'inactive',\n  pending: 'pending',\n};\n\n/**\n * Checks if a user is active\n * @function isActive\n * @tag users\n * @param {Object} - User object containing status information\n * @return {boolean} - Returns true if the user is active, otherwise false\n * @example\n *\n * isActive({status: 'active'}) // true\n * isActive({status: 'inactive'}) //false\n * isActive({status: 'pending'}) //false\n *\n */\nconst isActive = propEq('status', STATUS.active);\n\n/**\n * Checks if a user is inactive\n * @function isInActive\n * @tag users\n * @param {Object} - User object containing status information\n * @return {boolean} - Returns true if the user is inactive, otherwise false\n * @example\n *\n * isActive({status: 'active'}) // false\n * isActive({status: 'inactive'}) //true\n * isActive({status: 'pending'}) //false\n *\n */\nconst isInActive = propEq('status', STATUS.inactive);\n\n/**\n * Checks if a user is pending\n * @function isPending\n * @tag users\n * @param {Object} - User object containing status information\n * @return {boolean} - Returns true if the user is pending, otherwise false\n * @example\n *\n * isActive({status: 'active'}) // false\n * isActive({status: 'inactive'}) //false\n * isActive({status: 'pending'}) //true\n *\n */\nconst isPending = propEq('status', STATUS.pending);\n\n/**\n * Retrieves permissions from user roles\n * @function getRolesPermissions\n * @tag users\n * @param {Array|string} - User roles\n * @return {Array} - Array of permissions\n */\nconst getRolesPermissions = roles => {\n  if (!roles) return []\n  const permissions = [];\n  for (const role of is(Array, roles) ? roles : [roles]) {\n    for (const permission of hroles[role]?.permissions || []) {\n      permissions.push(permission);\n    }\n  }\n  return permissions\n};\n\nexport { ROLES, STATUS, getMemberIds, getRolesPermissions, getWritableAgencies, hasAgencies, hasAllRoles, hasMember, hasPermission, hasPermissions, hasRole, hasRoles, hasRootRole, hasSomeRoles, isActive, isAdmin, isInActive, isPending };\n//# sourceMappingURL=index.mjs.map\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/ap.js

@@ -0,0 +1,44 @@
+import _concat from './internal/_concat.js';
+import _curry2 from './internal/_curry2.js';
+import _reduce from './internal/_reduce.js';
+import map from './map.js';
+
+/**
+ * ap applies a list of functions to a list of values.
+ *
+ * Dispatches to the `ap` method of the second argument, if present. Also
+ * treats curried functions as applicatives.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category Function
+ * @sig [a -> b] -> [a] -> [b]
+ * @sig Apply f => f (a -> b) -> f a -> f b
+ * @sig (r -> a -> b) -> (r -> a) -> (r -> b)
+ * @param {*} applyF
+ * @param {*} applyX
+ * @return {*}
+ * @example
+ *
+ *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]
+ *      R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> ["tasty pizza", "tasty salad", "PIZZA", "SALAD"]
+ *
+ *      // R.ap can also be used as S combinator
+ *      // when only two functions are passed
+ *      R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'
+ * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]
+ */
+
+var ap =
+/*#__PURE__*/
+_curry2(function ap(applyF, applyX) {
+  return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {
+    return applyF(x)(applyX(x));
+  } : _reduce(function (acc, f) {
+    return _concat(acc, map(f, applyX));
+  }, [], applyF);
+});
+
+export { ap as default };
+//# sourceMappingURL=ap.js.map

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/ap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ap.js","sources":["../../../../../../../../node_modules/@dbmx/users/esm/node_modules/ramda/es/ap.mjs"],"sourcesContent":["import _concat from './internal/_concat.mjs';\nimport _curry2 from './internal/_curry2.mjs';\nimport _reduce from './internal/_reduce.mjs';\nimport map from './map.mjs';\n\n/**\n * ap applies a list of functions to a list of values.\n *\n * Dispatches to the `ap` method of the second argument, if present. Also\n * treats curried functions as applicatives.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig [a -> b] -> [a] -> [b]\n * @sig Apply f => f (a -> b) -> f a -> f b\n * @sig (r -> a -> b) -> (r -> a) -> (r -> b)\n * @param {*} applyF\n * @param {*} applyX\n * @return {*}\n * @example\n *\n *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n *      R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> [\"tasty pizza\", \"tasty salad\", \"PIZZA\", \"SALAD\"]\n *\n *      // R.ap can also be used as S combinator\n *      // when only two functions are passed\n *      R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'\n * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]\n */\n\nvar ap =\n/*#__PURE__*/\n_curry2(function ap(applyF, applyX) {\n  return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {\n    return applyF(x)(applyX(x));\n  } : _reduce(function (acc, f) {\n    return _concat(acc, map(f, applyX));\n  }, [], applyF);\n});\n\nexport { ap as default };\n//# sourceMappingURL=ap.mjs.map\n"],"names":[],"mappings":";;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEG,IAAC,EAAE;AACN;AACA,OAAO,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE;AACpC,EAAE,OAAO,OAAO,MAAM,CAAC,iBAAiB,CAAC,KAAK,UAAU,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,GAAG,OAAO,MAAM,CAAC,EAAE,KAAK,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,OAAO,MAAM,KAAK,UAAU,GAAG,UAAU,CAAC,EAAE;AACjM,IAAI,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC/B,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,EAAE,CAAC,EAAE;AAChC,IAAI,OAAO,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACvC,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC;AAChB,CAAC;;;;","x_google_ignoreList":[0]}

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/bind.js

@@ -0,0 +1,36 @@
+import _arity from './internal/_arity.js';
+import _curry2 from './internal/_curry2.js';
+
+/**
+ * Creates a function that is bound to a context.
+ * Note: `R.bind` does not provide the additional argument-binding capabilities of
+ * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category Function
+ * @category Object
+ * @sig (* -> *) -> {*} -> (* -> *)
+ * @param {Function} fn The function to bind to context
+ * @param {Object} thisObj The context to bind `fn` to
+ * @return {Function} A function that will execute in the context of `thisObj`.
+ * @see R.partial
+ * @example
+ *
+ *      const log = R.bind(console.log, console);
+ *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
+ *      // logs {a: 2}
+ * @symb R.bind(f, o)(a, b) = f.call(o, a, b)
+ */
+
+var bind =
+/*#__PURE__*/
+_curry2(function bind(fn, thisObj) {
+  return _arity(fn.length, function () {
+    return fn.apply(thisObj, arguments);
+  });
+});
+
+export { bind as default };
+//# sourceMappingURL=bind.js.map

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/bind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.js","sources":["../../../../../../../../node_modules/@dbmx/users/esm/node_modules/ramda/es/bind.mjs"],"sourcesContent":["import _arity from './internal/_arity.mjs';\nimport _curry2 from './internal/_curry2.mjs';\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @category Object\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n * @see R.partial\n * @example\n *\n *      const log = R.bind(console.log, console);\n *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}\n *      // logs {a: 2}\n * @symb R.bind(f, o)(a, b) = f.call(o, a, b)\n */\n\nvar bind =\n/*#__PURE__*/\n_curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function () {\n    return fn.apply(thisObj, arguments);\n  });\n});\n\nexport { bind as default };\n//# sourceMappingURL=bind.mjs.map\n"],"names":[],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEG,IAAC,IAAI;AACR;AACA,OAAO,CAAC,SAAS,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE;AACnC,EAAE,OAAO,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY;AACvC,IAAI,OAAO,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC;AACvC,EAAE,CAAC,CAAC;AACJ,CAAC;;;;","x_google_ignoreList":[0]}

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/curry.js

@@ -0,0 +1,53 @@
+import _curry1 from './internal/_curry1.js';
+import curryN from './curryN.js';
+
+/**
+ * Returns a curried equivalent of the provided function. The curried function
+ * has two unusual capabilities. First, its arguments needn't be provided one
+ * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the
+ * following are equivalent:
+ *
+ *   - `g(1)(2)(3)`
+ *   - `g(1)(2, 3)`
+ *   - `g(1, 2)(3)`
+ *   - `g(1, 2, 3)`
+ *
+ * Secondly, the special placeholder value [`R.__`](#__) may be used to specify
+ * "gaps", allowing partial application of any combination of arguments,
+ * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),
+ * the following are equivalent:
+ *
+ *   - `g(1, 2, 3)`
+ *   - `g(_, 2, 3)(1)`
+ *   - `g(_, _, 3)(1)(2)`
+ *   - `g(_, _, 3)(1, 2)`
+ *   - `g(_, 2)(1)(3)`
+ *   - `g(_, 2)(1, 3)`
+ *   - `g(_, 2)(_, 3)(1)`
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (* -> a) -> (* -> a)
+ * @param {Function} fn The function to curry.
+ * @return {Function} A new, curried function.
+ * @see R.curryN, R.partial
+ * @example
+ *
+ *      const addFourNumbers = (a, b, c, d) => a + b + c + d;
+ *
+ *      const curriedAddFourNumbers = R.curry(addFourNumbers);
+ *      const f = curriedAddFourNumbers(1, 2);
+ *      const g = f(3);
+ *      g(4); //=> 10
+ */
+
+var curry =
+/*#__PURE__*/
+_curry1(function curry(fn) {
+  return curryN(fn.length, fn);
+});
+
+export { curry as default };
+//# sourceMappingURL=curry.js.map

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/curry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry.js","sources":["../../../../../../../../node_modules/@dbmx/users/esm/node_modules/ramda/es/curry.mjs"],"sourcesContent":["import _curry1 from './internal/_curry1.mjs';\nimport curryN from './curryN.mjs';\n\n/**\n * Returns a curried equivalent of the provided function. The curried function\n * has two unusual capabilities. First, its arguments needn't be provided one\n * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN, R.partial\n * @example\n *\n *      const addFourNumbers = (a, b, c, d) => a + b + c + d;\n *\n *      const curriedAddFourNumbers = R.curry(addFourNumbers);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\nvar curry =\n/*#__PURE__*/\n_curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n\nexport { curry as default };\n//# sourceMappingURL=curry.mjs.map\n"],"names":[],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEG,IAAC,KAAK;AACT;AACA,OAAO,CAAC,SAAS,KAAK,CAAC,EAAE,EAAE;AAC3B,EAAE,OAAO,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC;AAC9B,CAAC;;;;","x_google_ignoreList":[0]}

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/curryN.js

@@ -0,0 +1,60 @@
+import _arity from './internal/_arity.js';
+import _curry1 from './internal/_curry1.js';
+import _curry2 from './internal/_curry2.js';
+import _curryN from './internal/_curryN.js';
+
+/**
+ * Returns a curried equivalent of the provided function, with the specified
+ * arity. The curried function has two unusual capabilities. First, its
+ * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the
+ * following are equivalent:
+ *
+ *   - `g(1)(2)(3)`
+ *   - `g(1)(2, 3)`
+ *   - `g(1, 2)(3)`
+ *   - `g(1, 2, 3)`
+ *
+ * Secondly, the special placeholder value [`R.__`](#__) may be used to specify
+ * "gaps", allowing partial application of any combination of arguments,
+ * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),
+ * the following are equivalent:
+ *
+ *   - `g(1, 2, 3)`
+ *   - `g(_, 2, 3)(1)`
+ *   - `g(_, _, 3)(1)(2)`
+ *   - `g(_, _, 3)(1, 2)`
+ *   - `g(_, 2)(1)(3)`
+ *   - `g(_, 2)(1, 3)`
+ *   - `g(_, 2)(_, 3)(1)`
+ *
+ * @func
+ * @memberOf R
+ * @since v0.5.0
+ * @category Function
+ * @sig Number -> (* -> a) -> (* -> a)
+ * @param {Number} length The arity for the returned function.
+ * @param {Function} fn The function to curry.
+ * @return {Function} A new, curried function.
+ * @see R.curry
+ * @example
+ *
+ *      const sumArgs = (...args) => R.sum(args);
+ *
+ *      const curriedAddFourNumbers = R.curryN(4, sumArgs);
+ *      const f = curriedAddFourNumbers(1, 2);
+ *      const g = f(3);
+ *      g(4); //=> 10
+ */
+
+var curryN =
+/*#__PURE__*/
+_curry2(function curryN(length, fn) {
+  if (length === 1) {
+    return _curry1(fn);
+  }
+
+  return _arity(length, _curryN(length, [], fn));
+});
+
+export { curryN as default };
+//# sourceMappingURL=curryN.js.map

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/curryN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curryN.js","sources":["../../../../../../../../node_modules/@dbmx/users/esm/node_modules/ramda/es/curryN.mjs"],"sourcesContent":["import _arity from './internal/_arity.mjs';\nimport _curry1 from './internal/_curry1.mjs';\nimport _curry2 from './internal/_curry2.mjs';\nimport _curryN from './internal/_curryN.mjs';\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      const sumArgs = (...args) => R.sum(args);\n *\n *      const curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\nvar curryN =\n/*#__PURE__*/\n_curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n\n  return _arity(length, _curryN(length, [], fn));\n});\n\nexport { curryN as default };\n//# sourceMappingURL=curryN.mjs.map\n"],"names":[],"mappings":";;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEG,IAAC,MAAM;AACV;AACA,OAAO,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE;AACpC,EAAE,IAAI,MAAM,KAAK,CAAC,EAAE;AACpB,IAAI,OAAO,OAAO,CAAC,EAAE,CAAC;AACtB,EAAE;;AAEF,EAAE,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AAChD,CAAC;;;;","x_google_ignoreList":[0]}

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/difference.js

@@ -0,0 +1,50 @@
+import _curry2 from './internal/_curry2.js';
+import _Set from './internal/_Set.js';
+
+/**
+ * Finds the set (i.e. no duplicates) of all elements in the first list not
+ * contained in the second list. Objects and Arrays are compared in terms of
+ * value equality, not reference equality.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig [*] -> [*] -> [*]
+ * @param {Array} list1 The first list.
+ * @param {Array} list2 The second list.
+ * @return {Array} The elements in `list1` that are not in `list2`.
+ * @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith, R.without
+ * @example
+ *
+ *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]
+ *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]
+ *      R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]
+ */
+
+var difference =
+/*#__PURE__*/
+_curry2(function difference(first, second) {
+  var out = [];
+  var idx = 0;
+  var firstLen = first.length;
+  var secondLen = second.length;
+  var toFilterOut = new _Set();
+
+  for (var i = 0; i < secondLen; i += 1) {
+    toFilterOut.add(second[i]);
+  }
+
+  while (idx < firstLen) {
+    if (toFilterOut.add(first[idx])) {
+      out[out.length] = first[idx];
+    }
+
+    idx += 1;
+  }
+
+  return out;
+});
+
+export { difference as default };
+//# sourceMappingURL=difference.js.map

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/difference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.js","sources":["../../../../../../../../node_modules/@dbmx/users/esm/node_modules/ramda/es/difference.mjs"],"sourcesContent":["import _curry2 from './internal/_curry2.mjs';\nimport _Set from './internal/_Set.mjs';\n\n/**\n * Finds the set (i.e. no duplicates) of all elements in the first list not\n * contained in the second list. Objects and Arrays are compared in terms of\n * value equality, not reference equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` that are not in `list2`.\n * @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith, R.without\n * @example\n *\n *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n *      R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]\n */\n\nvar difference =\n/*#__PURE__*/\n_curry2(function difference(first, second) {\n  var out = [];\n  var idx = 0;\n  var firstLen = first.length;\n  var secondLen = second.length;\n  var toFilterOut = new _Set();\n\n  for (var i = 0; i < secondLen; i += 1) {\n    toFilterOut.add(second[i]);\n  }\n\n  while (idx < firstLen) {\n    if (toFilterOut.add(first[idx])) {\n      out[out.length] = first[idx];\n    }\n\n    idx += 1;\n  }\n\n  return out;\n});\n\nexport { difference as default };\n//# sourceMappingURL=difference.mjs.map\n"],"names":[],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEG,IAAC,UAAU;AACd;AACA,OAAO,CAAC,SAAS,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE;AAC3C,EAAE,IAAI,GAAG,GAAG,EAAE;AACd,EAAE,IAAI,GAAG,GAAG,CAAC;AACb,EAAE,IAAI,QAAQ,GAAG,KAAK,CAAC,MAAM;AAC7B,EAAE,IAAI,SAAS,GAAG,MAAM,CAAC,MAAM;AAC/B,EAAE,IAAI,WAAW,GAAG,IAAI,IAAI,EAAE;;AAE9B,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE;AACzC,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC9B,EAAE;;AAEF,EAAE,OAAO,GAAG,GAAG,QAAQ,EAAE;AACzB,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE;AACrC,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;AAClC,IAAI;;AAEJ,IAAI,GAAG,IAAI,CAAC;AACZ,EAAE;;AAEF,EAAE,OAAO,GAAG;AACZ,CAAC;;;;","x_google_ignoreList":[0]}

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/either.js

@@ -0,0 +1,46 @@
+import _curry2 from './internal/_curry2.js';
+import _isFunction from './internal/_isFunction.js';
+import lift from './lift.js';
+import or from './or.js';
+
+/**
+ * A function wrapping calls to the two functions in an `||` operation,
+ * returning the result of the first function if it is truth-y and the result
+ * of the second function otherwise. Note that this is short-circuited,
+ * meaning that the second function will not be invoked if the first returns a
+ * truth-y value.
+ *
+ * In addition to functions, `R.either` also accepts any fantasy-land compatible
+ * applicative functor.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category Logic
+ * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
+ * @param {Function} f a predicate
+ * @param {Function} g another predicate
+ * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.
+ * @see R.or
+ * @example
+ *
+ *      const gt10 = x => x > 10;
+ *      const even = x => x % 2 === 0;
+ *      const f = R.either(gt10, even);
+ *      f(101); //=> true
+ *      f(8); //=> true
+ *
+ *      R.either(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(55)
+ *      R.either([false, false, 'a'], [11]) // => [11, 11, "a"]
+ */
+
+var either =
+/*#__PURE__*/
+_curry2(function either(f, g) {
+  return _isFunction(f) ? function _either() {
+    return f.apply(this, arguments) || g.apply(this, arguments);
+  } : lift(or)(f, g);
+});
+
+export { either as default };
+//# sourceMappingURL=either.js.map

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/either.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"either.js","sources":["../../../../../../../../node_modules/@dbmx/users/esm/node_modules/ramda/es/either.mjs"],"sourcesContent":["import _curry2 from './internal/_curry2.mjs';\nimport _isFunction from './internal/_isFunction.mjs';\nimport lift from './lift.mjs';\nimport or from './or.mjs';\n\n/**\n * A function wrapping calls to the two functions in an `||` operation,\n * returning the result of the first function if it is truth-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * truth-y value.\n *\n * In addition to functions, `R.either` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f a predicate\n * @param {Function} g another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n * @see R.or\n * @example\n *\n *      const gt10 = x => x > 10;\n *      const even = x => x % 2 === 0;\n *      const f = R.either(gt10, even);\n *      f(101); //=> true\n *      f(8); //=> true\n *\n *      R.either(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(55)\n *      R.either([false, false, 'a'], [11]) // => [11, 11, \"a\"]\n */\n\nvar either =\n/*#__PURE__*/\n_curry2(function either(f, g) {\n  return _isFunction(f) ? function _either() {\n    return f.apply(this, arguments) || g.apply(this, arguments);\n  } : lift(or)(f, g);\n});\n\nexport { either as default };\n//# sourceMappingURL=either.mjs.map\n"],"names":[],"mappings":";;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEG,IAAC,MAAM;AACV;AACA,OAAO,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE;AAC9B,EAAE,OAAO,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,OAAO,GAAG;AAC7C,IAAI,OAAO,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC;AAC/D,EAAE,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AACpB,CAAC;;;;","x_google_ignoreList":[0]}

package/esm/node_modules/@dbmx/users/esm/node_modules/ramda/es/equals.js

@@ -0,0 +1,37 @@
+import _curry2 from './internal/_curry2.js';
+import _equals from './internal/_equals.js';
+
+/**
+ * Returns `true` if its arguments are equivalent, `false` otherwise. Handles
+ * cyclical data structures.
+ *
+ * Dispatches symmetrically to the `equals` methods of both arguments, if
+ * present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.15.0
+ * @category Relation
+ * @sig a -> b -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @example
+ *
+ *      R.equals(1, 1); //=> true
+ *      R.equals(1, '1'); //=> false
+ *      R.equals([1, 2, 3], [1, 2, 3]); //=> true
+ *
+ *      const a = {}; a.v = a;
+ *      const b = {}; b.v = b;
+ *      R.equals(a, b); //=> true
+ */
+
+var equals =
+/*#__PURE__*/
+_curry2(function equals(a, b) {
+  return _equals(a, b, [], []);
+});
+
+export { equals as default };
+//# sourceMappingURL=equals.js.map