@openmrs/esm-app-shell 10.0.1-pre.5635 → 10.0.1-pre.5649

package/lib/{0f63a955dacaced7.js → 0a6b767a56d12e92.js}

@@ -491,7 +491,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
 },
 "../../framework/esm-styleguide/dist/config-schema.js"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  esmStyleGuideSchema: () => (esmStyleGuideSchema)\n});\n/* import */ var _openmrs_esm_config__rspack_import_0 = __webpack_require__(\"../../framework/esm-config/dist/index.js\");\n/* import */ var _utils_js__rspack_import_1 = __webpack_require__(\"../../framework/esm-styleguide/dist/utils.js\");\n\n\nconst diagnosisTagConfigSchema = {\n    primaryColor: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.String,\n        _description: 'The color for displaying primary diagnoses tags',\n        _default: 'red',\n        _validators: [\n            _openmrs_esm_config__rspack_import_0.validators.oneOf(_utils_js__rspack_import_1.carbonTagColors)\n        ]\n    },\n    secondaryColor: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.String,\n        _description: 'The color for displaying secondary diagnoses tags',\n        _default: 'blue',\n        _validators: [\n            _openmrs_esm_config__rspack_import_0.validators.oneOf(_utils_js__rspack_import_1.carbonTagColors)\n        ]\n    }\n};\nconst esmStyleGuideSchema = {\n    'Brand color #1': {\n        _default: '#005d5d',\n        _type: _openmrs_esm_config__rspack_import_0.Type.String\n    },\n    'Brand color #2': {\n        _default: '#004144',\n        _type: _openmrs_esm_config__rspack_import_0.Type.String\n    },\n    'Brand color #3': {\n        _default: '#007d79',\n        _type: _openmrs_esm_config__rspack_import_0.Type.String\n    },\n    excludePatientIdentifierCodeTypes: {\n        uuids: {\n            _type: _openmrs_esm_config__rspack_import_0.Type.Array,\n            _description: 'List of UUIDs of patient identifier types to exclude from rendering in the patient banner',\n            _default: [],\n            _elements: {\n                _type: _openmrs_esm_config__rspack_import_0.Type.UUID\n            }\n        }\n    },\n    implementationName: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.String,\n        _description: 'A name of the place (or authority) where all possible locations a user can choose are located.',\n        _default: 'Clinic'\n    },\n    patientPhotoConceptUuid: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.ConceptUuid,\n        _default: '736e8771-e501-4615-bfa7-570c03f4bef5',\n        _description: \"Used to look up the patient photo, which is stored as an attachment obs. Set to `null` in order to disable the feature and use only generated avatars. To remove the avatars entirely, use extension configuration's `remove` feature.\"\n    },\n    preferredCalendar: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.Object,\n        _description: \"Keys should be locale codes, and values should be the preferred calendar for that locale. For example, {'am': 'ethiopic'}.\",\n        _default: {\n            am: 'ethiopic'\n        },\n        _elements: {\n            _validators: [\n                _openmrs_esm_config__rspack_import_0.validators.oneOf([\n                    'buddhist',\n                    'chinese',\n                    'coptic',\n                    'dangi',\n                    'ethioaa',\n                    'ethiopic',\n                    'gregory',\n                    'hebrew',\n                    'indian',\n                    'islamic',\n                    'islamic-umalqura',\n                    'islamic-tbla',\n                    'islamic-civil',\n                    'islamic-rgsa',\n                    'iso8601',\n                    'japanese',\n                    'persian',\n                    'roc',\n                    'islamicc'\n                ])\n            ]\n        }\n    },\n    preferredDateLocale: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.Object,\n        _description: \"Allows setting the locale used for date formatting for any browser locale. Does not affect time formatting. Keys should be locale codes, and values should be the preferred locale for formatting dates. For example, {'en': 'en-US', 'fr-CA': 'en-CA'}.\",\n        _default: {\n            en: 'en-GB'\n        },\n        _elements: {\n            _type: _openmrs_esm_config__rspack_import_0.Type.String\n        }\n    },\n    diagnosisTags: diagnosisTagConfigSchema\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n//# sourceURL=webpack-internal:///../../framework/esm-styleguide/dist/config-schema.js\n\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  esmStyleGuideSchema: () => (esmStyleGuideSchema)\n});\n/* import */ var _openmrs_esm_config__rspack_import_0 = __webpack_require__(\"../../framework/esm-config/dist/index.js\");\n/* import */ var _utils_js__rspack_import_1 = __webpack_require__(\"../../framework/esm-styleguide/dist/utils.js\");\n\n\nconst diagnosisTagConfigSchema = {\n    primaryColor: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.String,\n        _description: 'The color for displaying primary diagnoses tags',\n        _default: 'red',\n        _validators: [\n            _openmrs_esm_config__rspack_import_0.validators.oneOf(_utils_js__rspack_import_1.carbonTagColors)\n        ]\n    },\n    secondaryColor: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.String,\n        _description: 'The color for displaying secondary diagnoses tags',\n        _default: 'blue',\n        _validators: [\n            _openmrs_esm_config__rspack_import_0.validators.oneOf(_utils_js__rspack_import_1.carbonTagColors)\n        ]\n    }\n};\nconst esmStyleGuideSchema = {\n    'Brand color #1': {\n        _default: '#005d5d',\n        _type: _openmrs_esm_config__rspack_import_0.Type.String\n    },\n    'Brand color #2': {\n        _default: '#004144',\n        _type: _openmrs_esm_config__rspack_import_0.Type.String\n    },\n    'Brand color #3': {\n        _default: '#007d79',\n        _type: _openmrs_esm_config__rspack_import_0.Type.String\n    },\n    excludePatientIdentifierCodeTypes: {\n        uuids: {\n            _type: _openmrs_esm_config__rspack_import_0.Type.Array,\n            _description: 'List of UUIDs of patient identifier types to exclude from rendering in the patient banner',\n            _default: [],\n            _elements: {\n                _type: _openmrs_esm_config__rspack_import_0.Type.UUID\n            }\n        }\n    },\n    implementationName: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.String,\n        _description: 'A name of the place (or authority) where all possible locations a user can choose are located.',\n        _default: 'Clinic'\n    },\n    logo: {\n        src: {\n            _type: _openmrs_esm_config__rspack_import_0.Type.String,\n            _default: '',\n            _description: 'The path or URL to the logo shown on the login page and while the server is starting up. If set to an empty string, the default OpenMRS logo is used.',\n            _validators: [\n                _openmrs_esm_config__rspack_import_0.validators.isUrl\n            ]\n        },\n        alt: {\n            _type: _openmrs_esm_config__rspack_import_0.Type.String,\n            _default: 'Logo',\n            _description: 'The alternative text for the logo image, displayed when the image cannot be loaded or on hover.'\n        }\n    },\n    patientPhotoConceptUuid: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.ConceptUuid,\n        _default: '736e8771-e501-4615-bfa7-570c03f4bef5',\n        _description: \"Used to look up the patient photo, which is stored as an attachment obs. Set to `null` in order to disable the feature and use only generated avatars. To remove the avatars entirely, use extension configuration's `remove` feature.\"\n    },\n    preferredCalendar: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.Object,\n        _description: \"Keys should be locale codes, and values should be the preferred calendar for that locale. For example, {'am': 'ethiopic'}.\",\n        _default: {\n            am: 'ethiopic'\n        },\n        _elements: {\n            _validators: [\n                _openmrs_esm_config__rspack_import_0.validators.oneOf([\n                    'buddhist',\n                    'chinese',\n                    'coptic',\n                    'dangi',\n                    'ethioaa',\n                    'ethiopic',\n                    'gregory',\n                    'hebrew',\n                    'indian',\n                    'islamic',\n                    'islamic-umalqura',\n                    'islamic-tbla',\n                    'islamic-civil',\n                    'islamic-rgsa',\n                    'iso8601',\n                    'japanese',\n                    'persian',\n                    'roc',\n                    'islamicc'\n                ])\n            ]\n        }\n    },\n    preferredDateLocale: {\n        _type: _openmrs_esm_config__rspack_import_0.Type.Object,\n        _description: \"Allows setting the locale used for date formatting for any browser locale. Does not affect time formatting. Keys should be locale codes, and values should be the preferred locale for formatting dates. For example, {'en': 'en-US', 'fr-CA': 'en-CA'}.\",\n        _default: {\n            en: 'en-GB'\n        },\n        _elements: {\n            _type: _openmrs_esm_config__rspack_import_0.Type.String\n        }\n    },\n    diagnosisTags: diagnosisTagConfigSchema\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n//# sourceURL=webpack-internal:///../../framework/esm-styleguide/dist/config-schema.js\n\n}");
 
 },
 "../../framework/esm-styleguide/dist/custom-overflow-menu/custom-overflow-menu.component.js"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -4456,7 +4456,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
 },
 "../../framework/esm-api/dist/current-user.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  clearCurrentUser: () => (clearCurrentUser),\n  getCurrentUser: () => (getCurrentUser),\n  getLoggedInUser: () => (getLoggedInUser),\n  getSessionLocation: () => (getSessionLocation),\n  getSessionStore: () => (getSessionStore),\n  logout: () => (logout),\n  refetchCurrentUser: () => (refetchCurrentUser),\n  sessionStore: () => (sessionStore),\n  setSessionLocale: () => (setSessionLocale),\n  setSessionLocation: () => (setSessionLocation),\n  setUserLanguage: () => (setUserLanguage),\n  setUserProperties: () => (setUserProperties),\n  userHasAccess: () => (userHasAccess),\n  verifyTotpCode: () => (verifyTotpCode)\n});\n/* import */ var _openmrs_esm_error_handling__rspack_import_0 = __webpack_require__(\"../../framework/esm-error-handling/dist/index.js\");\n/* import */ var _openmrs_esm_state__rspack_import_1 = __webpack_require__(\"../../framework/esm-state/dist/index.js\");\n/* import */ var lodash_es__rspack_import_3 = __webpack_require__(\"../../../node_modules/lodash-es/isUndefined.js\");\n/* import */ var _openmrs_fetch_js__rspack_import_2 = __webpack_require__(\"../../framework/esm-api/dist/openmrs-fetch.js\");\n/** @module @category API */ \n\n\n\n/** @internal */ const sessionStore = (0,_openmrs_esm_state__rspack_import_1.createGlobalStore)('session', {\n    loaded: false,\n    session: null\n});\n/**\n * The upper bound on how old the session handed to a reader may be. It is measured from the moment a\n * fetch is *started*, not from the moment its response lands, so the session a reader sees is always\n * strictly newer than this.\n */ const sessionMaxAgeMillis = 60 * 1000;\nlet lastFetchTimeMillis = 0;\nlet inFlightRefresh = null;\n/**\n * Fetches the session if the store is unloaded or its session is older than `sessionMaxAgeMillis`.\n * Returns `null` only when the store already holds a session fresh enough to be read as-is, so a\n * caller that gets a promise back must wait for it rather than read the store.\n *\n * A fetch already in flight is joined rather than duplicated. This is what keeps `sessionMaxAgeMillis`\n * an upper bound: while a fetch is running, the store still holds the previous session, and returning\n * that would hand back data older than the bound allows.\n *\n * The returned promise rejects if the fetch fails, but the rejection is already handled and reported,\n * so a caller that only needs the fetch started can ignore it.\n */ function refreshSessionIfStale() {\n    if (inFlightRefresh) {\n        return inFlightRefresh;\n    }\n    if (sessionStore.getState().loaded && lastFetchTimeMillis >= Date.now() - sessionMaxAgeMillis) {\n        return null;\n    }\n    return refetchCurrentUser();\n}\nfunction getCurrentUser(opts) {\n    const includeAuthStatus = opts?.includeAuthStatus ?? true;\n    const select = (session)=>includeAuthStatus ? session : session.user;\n    const refresh = refreshSessionIfStale();\n    if (!refresh) {\n        return Promise.resolve(select(sessionStore.getState().session));\n    }\n    return new Promise((resolve)=>{\n        const resolveIfLoaded = ()=>{\n            const state = sessionStore.getState();\n            if (state.loaded) {\n                unsubscribe();\n                resolve(select(state.session));\n            }\n        };\n        const unsubscribe = sessionStore.subscribe(resolveIfLoaded);\n        // A failed refresh keeps an already-loaded session without updating the store, so the\n        // subscription alone would never fire.\n        refresh.then(resolveIfLoaded, resolveIfLoaded);\n    });\n}\n\n/**\n * Returns the global session store containing the current user's session information.\n * If the session data is stale (older than 1 minute) or not yet loaded, this function\n * will trigger a refetch of the current user's session.\n *\n * @returns The global session store that can be subscribed to for session updates.\n *\n * @example\n * ```ts\n * import { getSessionStore } from '@openmrs/esm-api';\n * const store = getSessionStore();\n * const unsubscribe = store.subscribe((state) => {\n *   if (state.loaded) {\n *     console.log('Session:', state.session);\n *   }\n * });\n * ```\n */ function getSessionStore() {\n    refreshSessionIfStale();\n    return sessionStore;\n}\n// NB locale is string only if this returns true\nfunction isValidLocale(locale) {\n    if (locale === undefined || typeof locale !== 'string') {\n        return false;\n    }\n    try {\n        new Intl.Locale(locale);\n    } catch (e) {\n        return false;\n    }\n    return true;\n}\n/**\n * Sets the document's language attribute based on the user's locale preference\n * from the session data. This affects the HTML `lang` attribute which is used\n * for accessibility and internationalization.\n *\n * The locale is determined from either the session's locale or the user's\n * default locale property. Underscores in the locale are converted to hyphens\n * to match BCP 47 language tag format.\n *\n * @param data The session object containing locale information.\n */ function setUserLanguage(data) {\n    let locale = data.locale ?? data.user?.userProperties?.defaultLocale;\n    // Only underscores are converted here, deliberately, rather than reusing `toLanguageTag`. i18next\n    // reads this value back off `document.lang` and uses it as the translation bundle key, and those\n    // bundles are named with the POSIX form (`uz@Latn.json`), so converting `@` would send the loader\n    // after a bundle that does not exist.\n    if (locale && locale.includes('_')) {\n        locale = locale.replaceAll('_', '-');\n    }\n    if (isValidLocale(locale) && locale !== document.documentElement.getAttribute('lang')) {\n        document.documentElement.setAttribute('lang', locale);\n    }\n}\nsessionStore.subscribe((state)=>{\n    if (state.loaded && state.session) {\n        setUserLanguage(state.session);\n    }\n});\nfunction userHasPrivilege(requiredPrivilege, user) {\n    if (typeof requiredPrivilege === 'string') {\n        return !(0,lodash_es__rspack_import_3[\"default\"])(user.privileges.find((p)=>requiredPrivilege === p.display));\n    } else if (Array.isArray(requiredPrivilege)) {\n        return requiredPrivilege.every((rp)=>!(0,lodash_es__rspack_import_3[\"default\"])(user.privileges.find((p)=>rp === p.display)));\n    } else if (!(0,lodash_es__rspack_import_3[\"default\"])(requiredPrivilege)) {\n        console.error(`Could not understand privileges \"${requiredPrivilege}\"`);\n    }\n    return true;\n}\nfunction isSuperUser(user) {\n    return !(0,lodash_es__rspack_import_3[\"default\"])(user.roles.find((role)=>role.display === 'System Developer'));\n}\n/**\n * The `refetchCurrentUser` function causes a network request to redownload\n * the user. All subscribers to the session store will be notified of the\n * new user once the new version of the user object is downloaded.\n *\n * If the server rejects the request as unauthenticated (401 or 403), the store records a\n * logged-out session. If the request fails for any other reason, a session that has already\n * loaded is kept; otherwise the store records the error.\n *\n * @returns A Promise resolving to the updated session store state. It rejects with the\n *   store state if the request fails for a reason other than authentication.\n *\n * @example\n * ```js\n * import { refetchCurrentUser } from '@openmrs/esm-api'\n * refetchCurrentUser()\n * ```\n */ function refetchCurrentUser(username, password) {\n    lastFetchTimeMillis = Date.now();\n    let headers = {};\n    if (username && password) {\n        headers['Authorization'] = `Basic ${window.btoa(`${username}:${password}`)}`;\n    }\n    const refresh = handleSessionResponse((0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        headers,\n        rejectAuthFailure: true\n    }));\n    // Publish the request so that readers can wait on it instead of reading the session it is about to\n    // replace. Each call still issues its own request; this only tracks the most recent one.\n    const clear = ()=>{\n        if (inFlightRefresh === refresh) {\n            inFlightRefresh = null;\n        }\n    };\n    refresh.then(clear, clear);\n    inFlightRefresh = refresh;\n    return refresh;\n}\n/**\n * Clears the current user session from the session store, setting the session\n * to an unauthenticated state. This is typically called during logout to reset\n * the application's authentication state.\n *\n * @example\n * ```ts\n * import { clearCurrentUser } from '@openmrs/esm-api';\n * // During logout\n * clearCurrentUser();\n * ```\n */ function clearCurrentUser() {\n    sessionStore.setState({\n        loaded: true,\n        session: {\n            authenticated: false,\n            sessionId: ''\n        }\n    }, true);\n}\n/**\n * Checks whether the given user has access based on the required privilege(s).\n * A user has access if they have the required privilege(s) or if they are a\n * \"System Developer\" (super user). If no privilege is required, access is granted.\n *\n * @param requiredPrivilege A single privilege string or an array of privilege strings\n *   that the user must have. If an array is provided, the user must have ALL privileges.\n * @param user The user object containing their privileges and roles.\n * @returns `true` if the user has access, `false` otherwise. Returns `true` if no\n *   privilege is required, and `false` if the user is undefined but a privilege is required.\n *\n * @example\n * ```ts\n * import { userHasAccess } from '@openmrs/esm-api';\n * const hasAccess = userHasAccess('View Patients', currentUser);\n * const hasMultipleAccess = userHasAccess(['View Patients', 'Edit Patients'], currentUser);\n * ```\n */ function userHasAccess(requiredPrivilege, user) {\n    if (user === undefined) {\n        // if the user hasn't been loaded, then return false iff there is a required privilege\n        return !Boolean(requiredPrivilege);\n    }\n    if (!Boolean(requiredPrivilege)) {\n        // if user exists but no requiredPrivilege is defined\n        return true;\n    }\n    return userHasPrivilege(requiredPrivilege, user) || isSuperUser(user);\n}\n/**\n * Returns a Promise that resolves with the currently logged-in user object.\n * If the user is already loaded in the session store, the Promise resolves immediately.\n * Otherwise, it subscribes to the session store and resolves when a logged-in user\n * becomes available.\n *\n * @returns A Promise that resolves with the LoggedInUser object once available.\n *\n * @example\n * ```ts\n * import { getLoggedInUser } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * console.log('Logged in as:', user.display);\n * ```\n */ function getLoggedInUser() {\n    let user;\n    let unsubscribe;\n    return new Promise((res)=>{\n        const handler = (state)=>{\n            if (state.loaded && state.session.user) {\n                user = state.session.user;\n                res(state.session.user);\n                if (unsubscribe) {\n                    unsubscribe();\n                }\n            }\n        };\n        handler(sessionStore.getState());\n        if (!user) {\n            unsubscribe = sessionStore.subscribe(handler);\n        }\n    });\n}\n/**\n * Returns a Promise that resolves with the current session location, if one is set.\n * The session location represents the physical location where the user is currently\n * working (e.g., a clinic or ward).\n *\n * @returns A Promise that resolves with the SessionLocation object, or `undefined`\n *   if no session location is set.\n *\n * @example\n * ```ts\n * import { getSessionLocation } from '@openmrs/esm-api';\n * const location = await getSessionLocation();\n * if (location) {\n *   console.log('Current location:', location.display);\n * }\n * ```\n */ async function getSessionLocation() {\n    const session = await getCurrentUser();\n    return session.sessionLocation;\n}\n/**\n * Sets the session location for the current user. The session location represents\n * the physical location where the user is working (e.g., a clinic or ward).\n * This triggers a server request to update the session and refreshes the local\n * session store.\n *\n * @param locationUuid The UUID of the location to set as the session location.\n * @param abortController An AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore.\n *\n * @example\n * ```ts\n * import { setSessionLocation } from '@openmrs/esm-api';\n * const abortController = new AbortController();\n * await setSessionLocation('location-uuid-here', abortController);\n * ```\n */ async function setSessionLocation(locationUuid, abortController) {\n    return handleSessionResponse((0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        method: 'POST',\n        body: {\n            sessionLocation: locationUuid\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        rejectAuthFailure: true,\n        signal: abortController?.signal\n    }));\n}\n/**\n * Sets the locale for the current session only, leaving the user's default locale unchanged.\n * Use {@link setUserProperties} with a `defaultLocale` property to change the default instead.\n *\n * @param locale The locale in Java's `Locale#toString()` form, e.g. `en_GB`.\n * @param abortController Optional AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore after refetching the current user.\n *   It rejects with an {@link OpenmrsFetchError} if the server does not accept the locale.\n *\n * @example\n * ```ts\n * import { setSessionLocale } from '@openmrs/esm-api';\n * await setSessionLocale('fr');\n * ```\n *\n * @internal\n */ async function setSessionLocale(locale, abortController) {\n    await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        method: 'POST',\n        body: {\n            locale\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController?.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Updates the user properties for a specific user. User properties are key-value\n * pairs that store user-specific settings and preferences. After updating the\n * properties on the server, the current user session is refetched to reflect\n * the changes.\n *\n * @param userUuid The UUID of the user whose properties should be updated.\n * @param userProperties An object containing the properties to set or update.\n * @param abortController Optional AbortController to allow cancellation of the request.\n *   If not provided, a new AbortController is created.\n * @returns A Promise that resolves with the updated SessionStore after refetching\n *   the current user.\n *\n * @example\n * ```ts\n * import { getLoggedInUser, setUserProperties } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * await setUserProperties(user.uuid, {\n *   defaultLocale: 'en_GB',\n *   customSetting: 'value'\n * });\n * ```\n */ async function setUserProperties(userUuid, userProperties, abortController) {\n    if (!abortController) {\n        abortController = new AbortController();\n    }\n    await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(`${_openmrs_fetch_js__rspack_import_2.restBaseUrl}/user/${userUuid}`, {\n        method: 'POST',\n        body: {\n            userProperties\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Submits a TOTP code to complete a two-factor login challenge. When the code is accepted, the\n * session store is refreshed with the now-authenticated session.\n *\n * @param code The code from the user's authenticator app.\n * @param rememberDevice Whether the server should skip the challenge on this device in future.\n * @returns A Promise resolving to the session. Its `authenticated` property is `false` if the\n *   code was not accepted. It rejects with an {@link OpenmrsFetchError} if the server rejects the\n *   request, in which case `responseBody` may explain why.\n *\n * @example\n * ```ts\n * import { verifyTotpCode } from '@openmrs/esm-api';\n * const session = await verifyTotpCode('123456', true);\n * ```\n *\n * @internal\n */ async function verifyTotpCode(code, rememberDevice = false) {\n    const response = await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(rememberDevice ? `${_openmrs_fetch_js__rspack_import_2.sessionEndpoint}?rememberMe=true` : _openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        headers: {\n            'X-Totp-Code': code\n        }\n    });\n    if (response.data?.authenticated) {\n        // `refetchCurrentUser` only resolves once the store holds a session.\n        const store = await refetchCurrentUser();\n        return store.session;\n    }\n    return response.data;\n}\n/**\n * Ends the current session on the server and records a logged-out session in the session store.\n * A server that has already ended the session (401 or 403) counts as a successful logout.\n *\n * Other data cached for the logged-in user, such as SWR caches, is the caller's to clear.\n *\n * @returns A Promise that resolves once the session store holds a logged-out session.\n *\n * @example\n * ```ts\n * import { logout } from '@openmrs/esm-api';\n * await logout();\n * ```\n *\n * @internal\n */ async function logout() {\n    try {\n        await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n            method: 'DELETE',\n            rejectAuthFailure: true\n        });\n    } catch (err) {\n        if (!isAuthFailure(err)) {\n            throw err;\n        }\n    }\n    clearCurrentUser();\n    // The session just cleared is already correct, so a failed refresh loses nothing.\n    await refetchCurrentUser().catch(()=>{});\n}\nfunction handleSessionResponse(result) {\n    return new Promise((resolve, reject)=>{\n        result.then((res)=>{\n            if (typeof res?.data === 'object') {\n                const nextState = {\n                    loaded: true,\n                    session: res.data\n                };\n                sessionStore.setState(nextState, true);\n                resolve(nextState);\n            } else {\n                reject(recordSessionFailure(Error('The session endpoint did not respond with a session')));\n            }\n        }).catch((err)=>{\n            // An auth failure is the session endpoint's answer for \"not logged in\", not a failed lookup.\n            if (isAuthFailure(err)) {\n                if (isUnauthenticatedSession(err.responseBody)) {\n                    sessionStore.setState({\n                        loaded: true,\n                        session: err.responseBody\n                    }, true);\n                } else {\n                    clearCurrentUser();\n                }\n                resolve(sessionStore.getState());\n                return;\n            }\n            (0,_openmrs_esm_error_handling__rspack_import_0.reportError)(`Failed to fetch new session information: ${err}`);\n            reject(recordSessionFailure(err));\n        });\n    });\n}\nfunction isAuthFailure(err) {\n    return err instanceof _openmrs_fetch_js__rspack_import_2.OpenmrsFetchError && (err.response.status === 401 || err.response.status === 403);\n}\nfunction isUnauthenticatedSession(body) {\n    return typeof body === 'object' && body !== null && body.authenticated === false;\n}\n/**\n * A session that has already loaded is kept when a later fetch fails, since it is still the best answer\n * available. With nothing to fall back on, the error is recorded so the app shell can show an error page.\n */ function recordSessionFailure(err) {\n    if (!sessionStore.getState().loaded) {\n        sessionStore.setState({\n            loaded: false,\n            session: null,\n            error: err instanceof Error ? err : Error(String(err))\n        }, true);\n    }\n    return sessionStore.getState();\n}\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-api/dist/current-user.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-api/dist/current-user.js?7129"],"sourcesContent":["/** @module @category API */ import { reportError } from \"@openmrs/esm-error-handling\";\nimport { createGlobalStore } from \"@openmrs/esm-state\";\nimport { isUndefined } from \"lodash-es\";\nimport { OpenmrsFetchError, openmrsFetch, restBaseUrl, sessionEndpoint } from \"./openmrs-fetch.js\";\n/** @internal */ export const sessionStore = createGlobalStore('session', {\n    loaded: false,\n    session: null\n});\n/**\n * The upper bound on how old the session handed to a reader may be. It is measured from the moment a\n * fetch is *started*, not from the moment its response lands, so the session a reader sees is always\n * strictly newer than this.\n */ const sessionMaxAgeMillis = 60 * 1000;\nlet lastFetchTimeMillis = 0;\nlet inFlightRefresh = null;\n/**\n * Fetches the session if the store is unloaded or its session is older than `sessionMaxAgeMillis`.\n * Returns `null` only when the store already holds a session fresh enough to be read as-is, so a\n * caller that gets a promise back must wait for it rather than read the store.\n *\n * A fetch already in flight is joined rather than duplicated. This is what keeps `sessionMaxAgeMillis`\n * an upper bound: while a fetch is running, the store still holds the previous session, and returning\n * that would hand back data older than the bound allows.\n *\n * The returned promise rejects if the fetch fails, but the rejection is already handled and reported,\n * so a caller that only needs the fetch started can ignore it.\n */ function refreshSessionIfStale() {\n    if (inFlightRefresh) {\n        return inFlightRefresh;\n    }\n    if (sessionStore.getState().loaded && lastFetchTimeMillis >= Date.now() - sessionMaxAgeMillis) {\n        return null;\n    }\n    return refetchCurrentUser();\n}\nfunction getCurrentUser(opts) {\n    const includeAuthStatus = opts?.includeAuthStatus ?? true;\n    const select = (session)=>includeAuthStatus ? session : session.user;\n    const refresh = refreshSessionIfStale();\n    if (!refresh) {\n        return Promise.resolve(select(sessionStore.getState().session));\n    }\n    return new Promise((resolve)=>{\n        const resolveIfLoaded = ()=>{\n            const state = sessionStore.getState();\n            if (state.loaded) {\n                unsubscribe();\n                resolve(select(state.session));\n            }\n        };\n        const unsubscribe = sessionStore.subscribe(resolveIfLoaded);\n        // A failed refresh keeps an already-loaded session without updating the store, so the\n        // subscription alone would never fire.\n        refresh.then(resolveIfLoaded, resolveIfLoaded);\n    });\n}\nexport { getCurrentUser };\n/**\n * Returns the global session store containing the current user's session information.\n * If the session data is stale (older than 1 minute) or not yet loaded, this function\n * will trigger a refetch of the current user's session.\n *\n * @returns The global session store that can be subscribed to for session updates.\n *\n * @example\n * ```ts\n * import { getSessionStore } from '@openmrs/esm-api';\n * const store = getSessionStore();\n * const unsubscribe = store.subscribe((state) => {\n *   if (state.loaded) {\n *     console.log('Session:', state.session);\n *   }\n * });\n * ```\n */ export function getSessionStore() {\n    refreshSessionIfStale();\n    return sessionStore;\n}\n// NB locale is string only if this returns true\nfunction isValidLocale(locale) {\n    if (locale === undefined || typeof locale !== 'string') {\n        return false;\n    }\n    try {\n        new Intl.Locale(locale);\n    } catch (e) {\n        return false;\n    }\n    return true;\n}\n/**\n * Sets the document's language attribute based on the user's locale preference\n * from the session data. This affects the HTML `lang` attribute which is used\n * for accessibility and internationalization.\n *\n * The locale is determined from either the session's locale or the user's\n * default locale property. Underscores in the locale are converted to hyphens\n * to match BCP 47 language tag format.\n *\n * @param data The session object containing locale information.\n */ export function setUserLanguage(data) {\n    let locale = data.locale ?? data.user?.userProperties?.defaultLocale;\n    // Only underscores are converted here, deliberately, rather than reusing `toLanguageTag`. i18next\n    // reads this value back off `document.lang` and uses it as the translation bundle key, and those\n    // bundles are named with the POSIX form (`uz@Latn.json`), so converting `@` would send the loader\n    // after a bundle that does not exist.\n    if (locale && locale.includes('_')) {\n        locale = locale.replaceAll('_', '-');\n    }\n    if (isValidLocale(locale) && locale !== document.documentElement.getAttribute('lang')) {\n        document.documentElement.setAttribute('lang', locale);\n    }\n}\nsessionStore.subscribe((state)=>{\n    if (state.loaded && state.session) {\n        setUserLanguage(state.session);\n    }\n});\nfunction userHasPrivilege(requiredPrivilege, user) {\n    if (typeof requiredPrivilege === 'string') {\n        return !isUndefined(user.privileges.find((p)=>requiredPrivilege === p.display));\n    } else if (Array.isArray(requiredPrivilege)) {\n        return requiredPrivilege.every((rp)=>!isUndefined(user.privileges.find((p)=>rp === p.display)));\n    } else if (!isUndefined(requiredPrivilege)) {\n        console.error(`Could not understand privileges \"${requiredPrivilege}\"`);\n    }\n    return true;\n}\nfunction isSuperUser(user) {\n    return !isUndefined(user.roles.find((role)=>role.display === 'System Developer'));\n}\n/**\n * The `refetchCurrentUser` function causes a network request to redownload\n * the user. All subscribers to the session store will be notified of the\n * new user once the new version of the user object is downloaded.\n *\n * If the server rejects the request as unauthenticated (401 or 403), the store records a\n * logged-out session. If the request fails for any other reason, a session that has already\n * loaded is kept; otherwise the store records the error.\n *\n * @returns A Promise resolving to the updated session store state. It rejects with the\n *   store state if the request fails for a reason other than authentication.\n *\n * @example\n * ```js\n * import { refetchCurrentUser } from '@openmrs/esm-api'\n * refetchCurrentUser()\n * ```\n */ export function refetchCurrentUser(username, password) {\n    lastFetchTimeMillis = Date.now();\n    let headers = {};\n    if (username && password) {\n        headers['Authorization'] = `Basic ${window.btoa(`${username}:${password}`)}`;\n    }\n    const refresh = handleSessionResponse(openmrsFetch(sessionEndpoint, {\n        headers,\n        rejectAuthFailure: true\n    }));\n    // Publish the request so that readers can wait on it instead of reading the session it is about to\n    // replace. Each call still issues its own request; this only tracks the most recent one.\n    const clear = ()=>{\n        if (inFlightRefresh === refresh) {\n            inFlightRefresh = null;\n        }\n    };\n    refresh.then(clear, clear);\n    inFlightRefresh = refresh;\n    return refresh;\n}\n/**\n * Clears the current user session from the session store, setting the session\n * to an unauthenticated state. This is typically called during logout to reset\n * the application's authentication state.\n *\n * @example\n * ```ts\n * import { clearCurrentUser } from '@openmrs/esm-api';\n * // During logout\n * clearCurrentUser();\n * ```\n */ export function clearCurrentUser() {\n    sessionStore.setState({\n        loaded: true,\n        session: {\n            authenticated: false,\n            sessionId: ''\n        }\n    }, true);\n}\n/**\n * Checks whether the given user has access based on the required privilege(s).\n * A user has access if they have the required privilege(s) or if they are a\n * \"System Developer\" (super user). If no privilege is required, access is granted.\n *\n * @param requiredPrivilege A single privilege string or an array of privilege strings\n *   that the user must have. If an array is provided, the user must have ALL privileges.\n * @param user The user object containing their privileges and roles.\n * @returns `true` if the user has access, `false` otherwise. Returns `true` if no\n *   privilege is required, and `false` if the user is undefined but a privilege is required.\n *\n * @example\n * ```ts\n * import { userHasAccess } from '@openmrs/esm-api';\n * const hasAccess = userHasAccess('View Patients', currentUser);\n * const hasMultipleAccess = userHasAccess(['View Patients', 'Edit Patients'], currentUser);\n * ```\n */ export function userHasAccess(requiredPrivilege, user) {\n    if (user === undefined) {\n        // if the user hasn't been loaded, then return false iff there is a required privilege\n        return !Boolean(requiredPrivilege);\n    }\n    if (!Boolean(requiredPrivilege)) {\n        // if user exists but no requiredPrivilege is defined\n        return true;\n    }\n    return userHasPrivilege(requiredPrivilege, user) || isSuperUser(user);\n}\n/**\n * Returns a Promise that resolves with the currently logged-in user object.\n * If the user is already loaded in the session store, the Promise resolves immediately.\n * Otherwise, it subscribes to the session store and resolves when a logged-in user\n * becomes available.\n *\n * @returns A Promise that resolves with the LoggedInUser object once available.\n *\n * @example\n * ```ts\n * import { getLoggedInUser } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * console.log('Logged in as:', user.display);\n * ```\n */ export function getLoggedInUser() {\n    let user;\n    let unsubscribe;\n    return new Promise((res)=>{\n        const handler = (state)=>{\n            if (state.loaded && state.session.user) {\n                user = state.session.user;\n                res(state.session.user);\n                if (unsubscribe) {\n                    unsubscribe();\n                }\n            }\n        };\n        handler(sessionStore.getState());\n        if (!user) {\n            unsubscribe = sessionStore.subscribe(handler);\n        }\n    });\n}\n/**\n * Returns a Promise that resolves with the current session location, if one is set.\n * The session location represents the physical location where the user is currently\n * working (e.g., a clinic or ward).\n *\n * @returns A Promise that resolves with the SessionLocation object, or `undefined`\n *   if no session location is set.\n *\n * @example\n * ```ts\n * import { getSessionLocation } from '@openmrs/esm-api';\n * const location = await getSessionLocation();\n * if (location) {\n *   console.log('Current location:', location.display);\n * }\n * ```\n */ export async function getSessionLocation() {\n    const session = await getCurrentUser();\n    return session.sessionLocation;\n}\n/**\n * Sets the session location for the current user. The session location represents\n * the physical location where the user is working (e.g., a clinic or ward).\n * This triggers a server request to update the session and refreshes the local\n * session store.\n *\n * @param locationUuid The UUID of the location to set as the session location.\n * @param abortController An AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore.\n *\n * @example\n * ```ts\n * import { setSessionLocation } from '@openmrs/esm-api';\n * const abortController = new AbortController();\n * await setSessionLocation('location-uuid-here', abortController);\n * ```\n */ export async function setSessionLocation(locationUuid, abortController) {\n    return handleSessionResponse(openmrsFetch(sessionEndpoint, {\n        method: 'POST',\n        body: {\n            sessionLocation: locationUuid\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        rejectAuthFailure: true,\n        signal: abortController?.signal\n    }));\n}\n/**\n * Sets the locale for the current session only, leaving the user's default locale unchanged.\n * Use {@link setUserProperties} with a `defaultLocale` property to change the default instead.\n *\n * @param locale The locale in Java's `Locale#toString()` form, e.g. `en_GB`.\n * @param abortController Optional AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore after refetching the current user.\n *   It rejects with an {@link OpenmrsFetchError} if the server does not accept the locale.\n *\n * @example\n * ```ts\n * import { setSessionLocale } from '@openmrs/esm-api';\n * await setSessionLocale('fr');\n * ```\n *\n * @internal\n */ export async function setSessionLocale(locale, abortController) {\n    await openmrsFetch(sessionEndpoint, {\n        method: 'POST',\n        body: {\n            locale\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController?.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Updates the user properties for a specific user. User properties are key-value\n * pairs that store user-specific settings and preferences. After updating the\n * properties on the server, the current user session is refetched to reflect\n * the changes.\n *\n * @param userUuid The UUID of the user whose properties should be updated.\n * @param userProperties An object containing the properties to set or update.\n * @param abortController Optional AbortController to allow cancellation of the request.\n *   If not provided, a new AbortController is created.\n * @returns A Promise that resolves with the updated SessionStore after refetching\n *   the current user.\n *\n * @example\n * ```ts\n * import { getLoggedInUser, setUserProperties } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * await setUserProperties(user.uuid, {\n *   defaultLocale: 'en_GB',\n *   customSetting: 'value'\n * });\n * ```\n */ export async function setUserProperties(userUuid, userProperties, abortController) {\n    if (!abortController) {\n        abortController = new AbortController();\n    }\n    await openmrsFetch(`${restBaseUrl}/user/${userUuid}`, {\n        method: 'POST',\n        body: {\n            userProperties\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Submits a TOTP code to complete a two-factor login challenge. When the code is accepted, the\n * session store is refreshed with the now-authenticated session.\n *\n * @param code The code from the user's authenticator app.\n * @param rememberDevice Whether the server should skip the challenge on this device in future.\n * @returns A Promise resolving to the session. Its `authenticated` property is `false` if the\n *   code was not accepted. It rejects with an {@link OpenmrsFetchError} if the server rejects the\n *   request, in which case `responseBody` may explain why.\n *\n * @example\n * ```ts\n * import { verifyTotpCode } from '@openmrs/esm-api';\n * const session = await verifyTotpCode('123456', true);\n * ```\n *\n * @internal\n */ export async function verifyTotpCode(code, rememberDevice = false) {\n    const response = await openmrsFetch(rememberDevice ? `${sessionEndpoint}?rememberMe=true` : sessionEndpoint, {\n        headers: {\n            'X-Totp-Code': code\n        }\n    });\n    if (response.data?.authenticated) {\n        // `refetchCurrentUser` only resolves once the store holds a session.\n        const store = await refetchCurrentUser();\n        return store.session;\n    }\n    return response.data;\n}\n/**\n * Ends the current session on the server and records a logged-out session in the session store.\n * A server that has already ended the session (401 or 403) counts as a successful logout.\n *\n * Other data cached for the logged-in user, such as SWR caches, is the caller's to clear.\n *\n * @returns A Promise that resolves once the session store holds a logged-out session.\n *\n * @example\n * ```ts\n * import { logout } from '@openmrs/esm-api';\n * await logout();\n * ```\n *\n * @internal\n */ export async function logout() {\n    try {\n        await openmrsFetch(sessionEndpoint, {\n            method: 'DELETE',\n            rejectAuthFailure: true\n        });\n    } catch (err) {\n        if (!isAuthFailure(err)) {\n            throw err;\n        }\n    }\n    clearCurrentUser();\n    // The session just cleared is already correct, so a failed refresh loses nothing.\n    await refetchCurrentUser().catch(()=>{});\n}\nfunction handleSessionResponse(result) {\n    return new Promise((resolve, reject)=>{\n        result.then((res)=>{\n            if (typeof res?.data === 'object') {\n                const nextState = {\n                    loaded: true,\n                    session: res.data\n                };\n                sessionStore.setState(nextState, true);\n                resolve(nextState);\n            } else {\n                reject(recordSessionFailure(Error('The session endpoint did not respond with a session')));\n            }\n        }).catch((err)=>{\n            // An auth failure is the session endpoint's answer for \"not logged in\", not a failed lookup.\n            if (isAuthFailure(err)) {\n                if (isUnauthenticatedSession(err.responseBody)) {\n                    sessionStore.setState({\n                        loaded: true,\n                        session: err.responseBody\n                    }, true);\n                } else {\n                    clearCurrentUser();\n                }\n                resolve(sessionStore.getState());\n                return;\n            }\n            reportError(`Failed to fetch new session information: ${err}`);\n            reject(recordSessionFailure(err));\n        });\n    });\n}\nfunction isAuthFailure(err) {\n    return err instanceof OpenmrsFetchError && (err.response.status === 401 || err.response.status === 403);\n}\nfunction isUnauthenticatedSession(body) {\n    return typeof body === 'object' && body !== null && body.authenticated === false;\n}\n/**\n * A session that has already loaded is kept when a later fetch fails, since it is still the best answer\n * available. With nothing to fall back on, the error is recorded so the app shell can show an error page.\n */ function recordSessionFailure(err) {\n    if (!sessionStore.getState().loaded) {\n        sessionStore.setState({\n            loaded: false,\n            session: null,\n            error: err instanceof Error ? err : Error(String(err))\n        }, true);\n    }\n    return sessionStore.getState();\n}\n"],"names":["reportError","createGlobalStore","isUndefined","OpenmrsFetchError","openmrsFetch","restBaseUrl","sessionEndpoint","sessionStore","sessionMaxAgeMillis","lastFetchTimeMillis","inFlightRefresh","refreshSessionIfStale","Date","refetchCurrentUser","getCurrentUser","opts","includeAuthStatus","select","session","refresh","Promise","resolve","resolveIfLoaded","state","unsubscribe","getSessionStore","isValidLocale","locale","undefined","Intl","e","setUserLanguage","data","document","userHasPrivilege","requiredPrivilege","user","p","Array","rp","console","isSuperUser","role","username","password","headers","window","handleSessionResponse","clear","clearCurrentUser","userHasAccess","Boolean","getLoggedInUser","res","handler","getSessionLocation","setSessionLocation","locationUuid","abortController","setSessionLocale","setUserProperties","userUuid","userProperties","AbortController","verifyTotpCode","code","rememberDevice","response","store","logout","err","isAuthFailure","result","reject","nextState","recordSessionFailure","Error","isUnauthenticatedSession","body","String"],"mappings":"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"}\n//# sourceURL=webpack-internal:///../../framework/esm-api/dist/current-user.js\n\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  clearCurrentUser: () => (clearCurrentUser),\n  getCurrentUser: () => (getCurrentUser),\n  getLoggedInUser: () => (getLoggedInUser),\n  getSessionLocation: () => (getSessionLocation),\n  getSessionStore: () => (getSessionStore),\n  logout: () => (logout),\n  refetchCurrentUser: () => (refetchCurrentUser),\n  sessionStore: () => (sessionStore),\n  setSessionLocale: () => (setSessionLocale),\n  setSessionLocation: () => (setSessionLocation),\n  setUserLanguage: () => (setUserLanguage),\n  setUserProperties: () => (setUserProperties),\n  userHasAccess: () => (userHasAccess),\n  verifyTotpCode: () => (verifyTotpCode)\n});\n/* import */ var _openmrs_esm_error_handling__rspack_import_0 = __webpack_require__(\"../../framework/esm-error-handling/dist/index.js\");\n/* import */ var _openmrs_esm_state__rspack_import_1 = __webpack_require__(\"../../framework/esm-state/dist/index.js\");\n/* import */ var lodash_es__rspack_import_3 = __webpack_require__(\"../../../node_modules/lodash-es/isUndefined.js\");\n/* import */ var _openmrs_fetch_js__rspack_import_2 = __webpack_require__(\"../../framework/esm-api/dist/openmrs-fetch.js\");\n/** @module @category API */ \n\n\n\n/** @internal */ const sessionStore = (0,_openmrs_esm_state__rspack_import_1.createGlobalStore)('session', {\n    loaded: false,\n    session: null\n});\n/**\n * The upper bound on how old the session handed to a reader may be. It is measured from the moment a\n * fetch is *started*, not from the moment its response lands, so the session a reader sees is always\n * strictly newer than this.\n */ const sessionMaxAgeMillis = 60 * 1000;\nlet lastFetchTimeMillis = 0;\n/**\n * How long after the first session fetch a 502 is taken to mean that the backend is still starting up. A\n * gateway answers with a 502 until the backend has deployed, which can take a few minutes after a restart.\n */ const startupGracePeriodMillis = 3 * 60 * 1000;\nlet firstFetchTimeMillis;\nlet inFlightRefresh = null;\n/**\n * Fetches the session if the store is unloaded or its session is older than `sessionMaxAgeMillis`.\n * Returns `null` only when the store already holds a session fresh enough to be read as-is, so a\n * caller that gets a promise back must wait for it rather than read the store.\n *\n * A fetch already in flight is joined rather than duplicated. This is what keeps `sessionMaxAgeMillis`\n * an upper bound: while a fetch is running, the store still holds the previous session, and returning\n * that would hand back data older than the bound allows.\n *\n * The returned promise rejects if the fetch fails, but the rejection is already handled and reported,\n * so a caller that only needs the fetch started can ignore it.\n */ function refreshSessionIfStale() {\n    if (inFlightRefresh) {\n        return inFlightRefresh;\n    }\n    if (sessionStore.getState().loaded && lastFetchTimeMillis >= Date.now() - sessionMaxAgeMillis) {\n        return null;\n    }\n    return refetchCurrentUser();\n}\nfunction getCurrentUser(opts) {\n    const includeAuthStatus = opts?.includeAuthStatus ?? true;\n    const select = (session)=>includeAuthStatus ? session : session.user;\n    const refresh = refreshSessionIfStale();\n    if (!refresh) {\n        return Promise.resolve(select(sessionStore.getState().session));\n    }\n    return new Promise((resolve)=>{\n        const resolveIfLoaded = ()=>{\n            const state = sessionStore.getState();\n            if (state.loaded) {\n                unsubscribe();\n                resolve(select(state.session));\n            }\n        };\n        const unsubscribe = sessionStore.subscribe(resolveIfLoaded);\n        // A failed refresh keeps an already-loaded session without updating the store, so the\n        // subscription alone would never fire.\n        refresh.then(resolveIfLoaded, resolveIfLoaded);\n    });\n}\n\n/**\n * Returns the global session store containing the current user's session information.\n * If the session data is stale (older than 1 minute) or not yet loaded, this function\n * will trigger a refetch of the current user's session.\n *\n * @returns The global session store that can be subscribed to for session updates.\n *\n * @example\n * ```ts\n * import { getSessionStore } from '@openmrs/esm-api';\n * const store = getSessionStore();\n * const unsubscribe = store.subscribe((state) => {\n *   if (state.loaded) {\n *     console.log('Session:', state.session);\n *   }\n * });\n * ```\n */ function getSessionStore() {\n    refreshSessionIfStale();\n    return sessionStore;\n}\n// NB locale is string only if this returns true\nfunction isValidLocale(locale) {\n    if (locale === undefined || typeof locale !== 'string') {\n        return false;\n    }\n    try {\n        new Intl.Locale(locale);\n    } catch (e) {\n        return false;\n    }\n    return true;\n}\n/**\n * Sets the document's language attribute based on the user's locale preference\n * from the session data. This affects the HTML `lang` attribute which is used\n * for accessibility and internationalization.\n *\n * The locale is determined from either the session's locale or the user's\n * default locale property. Underscores in the locale are converted to hyphens\n * to match BCP 47 language tag format.\n *\n * @param data The session object containing locale information.\n */ function setUserLanguage(data) {\n    let locale = data.locale ?? data.user?.userProperties?.defaultLocale;\n    // Only underscores are converted here, deliberately, rather than reusing `toLanguageTag`. i18next\n    // reads this value back off `document.lang` and uses it as the translation bundle key, and those\n    // bundles are named with the POSIX form (`uz@Latn.json`), so converting `@` would send the loader\n    // after a bundle that does not exist.\n    if (locale && locale.includes('_')) {\n        locale = locale.replaceAll('_', '-');\n    }\n    if (isValidLocale(locale) && locale !== document.documentElement.getAttribute('lang')) {\n        document.documentElement.setAttribute('lang', locale);\n    }\n}\nsessionStore.subscribe((state)=>{\n    if (state.loaded && state.session) {\n        setUserLanguage(state.session);\n    }\n});\nfunction userHasPrivilege(requiredPrivilege, user) {\n    if (typeof requiredPrivilege === 'string') {\n        return !(0,lodash_es__rspack_import_3[\"default\"])(user.privileges.find((p)=>requiredPrivilege === p.display));\n    } else if (Array.isArray(requiredPrivilege)) {\n        return requiredPrivilege.every((rp)=>!(0,lodash_es__rspack_import_3[\"default\"])(user.privileges.find((p)=>rp === p.display)));\n    } else if (!(0,lodash_es__rspack_import_3[\"default\"])(requiredPrivilege)) {\n        console.error(`Could not understand privileges \"${requiredPrivilege}\"`);\n    }\n    return true;\n}\nfunction isSuperUser(user) {\n    return !(0,lodash_es__rspack_import_3[\"default\"])(user.roles.find((role)=>role.display === 'System Developer'));\n}\n/**\n * The `refetchCurrentUser` function causes a network request to redownload\n * the user. All subscribers to the session store will be notified of the\n * new user once the new version of the user object is downloaded.\n *\n * If the server rejects the request as unauthenticated (401 or 403), the store records a\n * logged-out session. If the request fails for any other reason, a session that has already\n * loaded is kept; otherwise the store records the error.\n *\n * @returns A Promise resolving to the updated session store state. It rejects with the\n *   store state if the request fails for a reason other than authentication.\n *\n * @example\n * ```js\n * import { refetchCurrentUser } from '@openmrs/esm-api'\n * refetchCurrentUser()\n * ```\n */ function refetchCurrentUser(username, password) {\n    lastFetchTimeMillis = Date.now();\n    firstFetchTimeMillis ?? (firstFetchTimeMillis = lastFetchTimeMillis);\n    let headers = {};\n    if (username && password) {\n        headers['Authorization'] = `Basic ${window.btoa(`${username}:${password}`)}`;\n    }\n    const refresh = handleSessionResponse((0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        headers,\n        rejectAuthFailure: true\n    }));\n    // Publish the request so that readers can wait on it instead of reading the session it is about to\n    // replace. Each call still issues its own request; this only tracks the most recent one.\n    const clear = ()=>{\n        if (inFlightRefresh === refresh) {\n            inFlightRefresh = null;\n        }\n    };\n    refresh.then(clear, clear);\n    inFlightRefresh = refresh;\n    return refresh;\n}\n/**\n * Clears the current user session from the session store, setting the session\n * to an unauthenticated state. This is typically called during logout to reset\n * the application's authentication state.\n *\n * @example\n * ```ts\n * import { clearCurrentUser } from '@openmrs/esm-api';\n * // During logout\n * clearCurrentUser();\n * ```\n */ function clearCurrentUser() {\n    sessionStore.setState({\n        loaded: true,\n        session: {\n            authenticated: false,\n            sessionId: ''\n        }\n    }, true);\n}\n/**\n * Checks whether the given user has access based on the required privilege(s).\n * A user has access if they have the required privilege(s) or if they are a\n * \"System Developer\" (super user). If no privilege is required, access is granted.\n *\n * @param requiredPrivilege A single privilege string or an array of privilege strings\n *   that the user must have. If an array is provided, the user must have ALL privileges.\n * @param user The user object containing their privileges and roles.\n * @returns `true` if the user has access, `false` otherwise. Returns `true` if no\n *   privilege is required, and `false` if the user is undefined but a privilege is required.\n *\n * @example\n * ```ts\n * import { userHasAccess } from '@openmrs/esm-api';\n * const hasAccess = userHasAccess('View Patients', currentUser);\n * const hasMultipleAccess = userHasAccess(['View Patients', 'Edit Patients'], currentUser);\n * ```\n */ function userHasAccess(requiredPrivilege, user) {\n    if (user === undefined) {\n        // if the user hasn't been loaded, then return false iff there is a required privilege\n        return !Boolean(requiredPrivilege);\n    }\n    if (!Boolean(requiredPrivilege)) {\n        // if user exists but no requiredPrivilege is defined\n        return true;\n    }\n    return userHasPrivilege(requiredPrivilege, user) || isSuperUser(user);\n}\n/**\n * Returns a Promise that resolves with the currently logged-in user object.\n * If the user is already loaded in the session store, the Promise resolves immediately.\n * Otherwise, it subscribes to the session store and resolves when a logged-in user\n * becomes available.\n *\n * @returns A Promise that resolves with the LoggedInUser object once available.\n *\n * @example\n * ```ts\n * import { getLoggedInUser } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * console.log('Logged in as:', user.display);\n * ```\n */ function getLoggedInUser() {\n    let user;\n    let unsubscribe;\n    return new Promise((res)=>{\n        const handler = (state)=>{\n            if (state.loaded && state.session.user) {\n                user = state.session.user;\n                res(state.session.user);\n                if (unsubscribe) {\n                    unsubscribe();\n                }\n            }\n        };\n        handler(sessionStore.getState());\n        if (!user) {\n            unsubscribe = sessionStore.subscribe(handler);\n        }\n    });\n}\n/**\n * Returns a Promise that resolves with the current session location, if one is set.\n * The session location represents the physical location where the user is currently\n * working (e.g., a clinic or ward).\n *\n * @returns A Promise that resolves with the SessionLocation object, or `undefined`\n *   if no session location is set.\n *\n * @example\n * ```ts\n * import { getSessionLocation } from '@openmrs/esm-api';\n * const location = await getSessionLocation();\n * if (location) {\n *   console.log('Current location:', location.display);\n * }\n * ```\n */ async function getSessionLocation() {\n    const session = await getCurrentUser();\n    return session.sessionLocation;\n}\n/**\n * Sets the session location for the current user. The session location represents\n * the physical location where the user is working (e.g., a clinic or ward).\n * This triggers a server request to update the session and refreshes the local\n * session store.\n *\n * @param locationUuid The UUID of the location to set as the session location.\n * @param abortController An AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore.\n *\n * @example\n * ```ts\n * import { setSessionLocation } from '@openmrs/esm-api';\n * const abortController = new AbortController();\n * await setSessionLocation('location-uuid-here', abortController);\n * ```\n */ async function setSessionLocation(locationUuid, abortController) {\n    return handleSessionResponse((0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        method: 'POST',\n        body: {\n            sessionLocation: locationUuid\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        rejectAuthFailure: true,\n        signal: abortController?.signal\n    }));\n}\n/**\n * Sets the locale for the current session only, leaving the user's default locale unchanged.\n * Use {@link setUserProperties} with a `defaultLocale` property to change the default instead.\n *\n * @param locale The locale in Java's `Locale#toString()` form, e.g. `en_GB`.\n * @param abortController Optional AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore after refetching the current user.\n *   It rejects with an {@link OpenmrsFetchError} if the server does not accept the locale.\n *\n * @example\n * ```ts\n * import { setSessionLocale } from '@openmrs/esm-api';\n * await setSessionLocale('fr');\n * ```\n *\n * @internal\n */ async function setSessionLocale(locale, abortController) {\n    await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        method: 'POST',\n        body: {\n            locale\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController?.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Updates the user properties for a specific user. User properties are key-value\n * pairs that store user-specific settings and preferences. After updating the\n * properties on the server, the current user session is refetched to reflect\n * the changes.\n *\n * @param userUuid The UUID of the user whose properties should be updated.\n * @param userProperties An object containing the properties to set or update.\n * @param abortController Optional AbortController to allow cancellation of the request.\n *   If not provided, a new AbortController is created.\n * @returns A Promise that resolves with the updated SessionStore after refetching\n *   the current user.\n *\n * @example\n * ```ts\n * import { getLoggedInUser, setUserProperties } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * await setUserProperties(user.uuid, {\n *   defaultLocale: 'en_GB',\n *   customSetting: 'value'\n * });\n * ```\n */ async function setUserProperties(userUuid, userProperties, abortController) {\n    if (!abortController) {\n        abortController = new AbortController();\n    }\n    await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(`${_openmrs_fetch_js__rspack_import_2.restBaseUrl}/user/${userUuid}`, {\n        method: 'POST',\n        body: {\n            userProperties\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Submits a TOTP code to complete a two-factor login challenge. When the code is accepted, the\n * session store is refreshed with the now-authenticated session.\n *\n * @param code The code from the user's authenticator app.\n * @param rememberDevice Whether the server should skip the challenge on this device in future.\n * @returns A Promise resolving to the session. Its `authenticated` property is `false` if the\n *   code was not accepted. It rejects with an {@link OpenmrsFetchError} if the server rejects the\n *   request, in which case `responseBody` may explain why.\n *\n * @example\n * ```ts\n * import { verifyTotpCode } from '@openmrs/esm-api';\n * const session = await verifyTotpCode('123456', true);\n * ```\n *\n * @internal\n */ async function verifyTotpCode(code, rememberDevice = false) {\n    const response = await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(rememberDevice ? `${_openmrs_fetch_js__rspack_import_2.sessionEndpoint}?rememberMe=true` : _openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n        headers: {\n            'X-Totp-Code': code\n        }\n    });\n    if (response.data?.authenticated) {\n        // `refetchCurrentUser` only resolves once the store holds a session.\n        const store = await refetchCurrentUser();\n        return store.session;\n    }\n    return response.data;\n}\n/**\n * Ends the current session on the server and records a logged-out session in the session store.\n * A server that has already ended the session (401 or 403) counts as a successful logout.\n *\n * Other data cached for the logged-in user, such as SWR caches, is the caller's to clear.\n *\n * @returns A Promise that resolves once the session store holds a logged-out session.\n *\n * @example\n * ```ts\n * import { logout } from '@openmrs/esm-api';\n * await logout();\n * ```\n *\n * @internal\n */ async function logout() {\n    try {\n        await (0,_openmrs_fetch_js__rspack_import_2.openmrsFetch)(_openmrs_fetch_js__rspack_import_2.sessionEndpoint, {\n            method: 'DELETE',\n            rejectAuthFailure: true\n        });\n    } catch (err) {\n        if (!isAuthFailure(err)) {\n            throw err;\n        }\n    }\n    clearCurrentUser();\n    // The session just cleared is already correct, so a failed refresh loses nothing.\n    await refetchCurrentUser().catch(()=>{});\n}\nfunction handleSessionResponse(result) {\n    return new Promise((resolve, reject)=>{\n        result.then((res)=>{\n            if (typeof res?.data === 'object') {\n                const nextState = {\n                    loaded: true,\n                    session: res.data\n                };\n                sessionStore.setState(nextState, true);\n                resolve(nextState);\n            } else if (isInitialSetupRedirect(res)) {\n                reject(recordSessionFailure(Error('The server is still starting up'), true));\n            } else {\n                reject(recordSessionFailure(Error('The session endpoint did not respond with a session')));\n            }\n        }).catch((err)=>{\n            // An auth failure is the session endpoint's answer for \"not logged in\", not a failed lookup.\n            if (isAuthFailure(err)) {\n                if (isUnauthenticatedSession(err.responseBody)) {\n                    sessionStore.setState({\n                        loaded: true,\n                        session: err.responseBody\n                    }, true);\n                } else {\n                    clearCurrentUser();\n                }\n                resolve(sessionStore.getState());\n                return;\n            }\n            if (isGatewayErrorDuringStartup(err)) {\n                reject(recordSessionFailure(err, true));\n                return;\n            }\n            (0,_openmrs_esm_error_handling__rspack_import_0.reportError)(`Failed to fetch new session information: ${err}`);\n            reject(recordSessionFailure(err));\n        });\n    });\n}\nfunction isAuthFailure(err) {\n    return err instanceof _openmrs_fetch_js__rspack_import_2.OpenmrsFetchError && (err.response.status === 401 || err.response.status === 403);\n}\n/**\n * Until the backend has finished its initial setup, it answers every request with a redirect to its\n * setup page, which `fetch()` follows, so the session request resolves with that page's HTML.\n */ function isInitialSetupRedirect(res) {\n    if (!res?.redirected || !res.url) {\n        return false;\n    }\n    try {\n        return new URL(res.url, window.location.href).pathname.replace(/\\/+$/, '').endsWith('/initialsetup');\n    } catch  {\n        return false;\n    }\n}\nfunction isGatewayErrorDuringStartup(err) {\n    return err instanceof _openmrs_fetch_js__rspack_import_2.OpenmrsFetchError && err.response.status === 502 && !sessionStore.getState().loaded && firstFetchTimeMillis !== undefined && Date.now() - firstFetchTimeMillis < startupGracePeriodMillis;\n}\nfunction isUnauthenticatedSession(body) {\n    return typeof body === 'object' && body !== null && body.authenticated === false;\n}\n/**\n * A session that has already loaded is kept when a later fetch fails, since it is still the best answer\n * available. With nothing to fall back on, the error is recorded so the app shell can show an error page.\n */ function recordSessionFailure(err, initializing = false) {\n    if (!sessionStore.getState().loaded) {\n        sessionStore.setState({\n            loaded: false,\n            session: null,\n            error: err instanceof Error ? err : Error(String(err)),\n            initializing\n        }, true);\n    }\n    return sessionStore.getState();\n}\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-api/dist/current-user.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-api/dist/current-user.js?7129"],"sourcesContent":["/** @module @category API */ import { reportError } from \"@openmrs/esm-error-handling\";\nimport { createGlobalStore } from \"@openmrs/esm-state\";\nimport { isUndefined } from \"lodash-es\";\nimport { OpenmrsFetchError, openmrsFetch, restBaseUrl, sessionEndpoint } from \"./openmrs-fetch.js\";\n/** @internal */ export const sessionStore = createGlobalStore('session', {\n    loaded: false,\n    session: null\n});\n/**\n * The upper bound on how old the session handed to a reader may be. It is measured from the moment a\n * fetch is *started*, not from the moment its response lands, so the session a reader sees is always\n * strictly newer than this.\n */ const sessionMaxAgeMillis = 60 * 1000;\nlet lastFetchTimeMillis = 0;\n/**\n * How long after the first session fetch a 502 is taken to mean that the backend is still starting up. A\n * gateway answers with a 502 until the backend has deployed, which can take a few minutes after a restart.\n */ const startupGracePeriodMillis = 3 * 60 * 1000;\nlet firstFetchTimeMillis;\nlet inFlightRefresh = null;\n/**\n * Fetches the session if the store is unloaded or its session is older than `sessionMaxAgeMillis`.\n * Returns `null` only when the store already holds a session fresh enough to be read as-is, so a\n * caller that gets a promise back must wait for it rather than read the store.\n *\n * A fetch already in flight is joined rather than duplicated. This is what keeps `sessionMaxAgeMillis`\n * an upper bound: while a fetch is running, the store still holds the previous session, and returning\n * that would hand back data older than the bound allows.\n *\n * The returned promise rejects if the fetch fails, but the rejection is already handled and reported,\n * so a caller that only needs the fetch started can ignore it.\n */ function refreshSessionIfStale() {\n    if (inFlightRefresh) {\n        return inFlightRefresh;\n    }\n    if (sessionStore.getState().loaded && lastFetchTimeMillis >= Date.now() - sessionMaxAgeMillis) {\n        return null;\n    }\n    return refetchCurrentUser();\n}\nfunction getCurrentUser(opts) {\n    const includeAuthStatus = opts?.includeAuthStatus ?? true;\n    const select = (session)=>includeAuthStatus ? session : session.user;\n    const refresh = refreshSessionIfStale();\n    if (!refresh) {\n        return Promise.resolve(select(sessionStore.getState().session));\n    }\n    return new Promise((resolve)=>{\n        const resolveIfLoaded = ()=>{\n            const state = sessionStore.getState();\n            if (state.loaded) {\n                unsubscribe();\n                resolve(select(state.session));\n            }\n        };\n        const unsubscribe = sessionStore.subscribe(resolveIfLoaded);\n        // A failed refresh keeps an already-loaded session without updating the store, so the\n        // subscription alone would never fire.\n        refresh.then(resolveIfLoaded, resolveIfLoaded);\n    });\n}\nexport { getCurrentUser };\n/**\n * Returns the global session store containing the current user's session information.\n * If the session data is stale (older than 1 minute) or not yet loaded, this function\n * will trigger a refetch of the current user's session.\n *\n * @returns The global session store that can be subscribed to for session updates.\n *\n * @example\n * ```ts\n * import { getSessionStore } from '@openmrs/esm-api';\n * const store = getSessionStore();\n * const unsubscribe = store.subscribe((state) => {\n *   if (state.loaded) {\n *     console.log('Session:', state.session);\n *   }\n * });\n * ```\n */ export function getSessionStore() {\n    refreshSessionIfStale();\n    return sessionStore;\n}\n// NB locale is string only if this returns true\nfunction isValidLocale(locale) {\n    if (locale === undefined || typeof locale !== 'string') {\n        return false;\n    }\n    try {\n        new Intl.Locale(locale);\n    } catch (e) {\n        return false;\n    }\n    return true;\n}\n/**\n * Sets the document's language attribute based on the user's locale preference\n * from the session data. This affects the HTML `lang` attribute which is used\n * for accessibility and internationalization.\n *\n * The locale is determined from either the session's locale or the user's\n * default locale property. Underscores in the locale are converted to hyphens\n * to match BCP 47 language tag format.\n *\n * @param data The session object containing locale information.\n */ export function setUserLanguage(data) {\n    let locale = data.locale ?? data.user?.userProperties?.defaultLocale;\n    // Only underscores are converted here, deliberately, rather than reusing `toLanguageTag`. i18next\n    // reads this value back off `document.lang` and uses it as the translation bundle key, and those\n    // bundles are named with the POSIX form (`uz@Latn.json`), so converting `@` would send the loader\n    // after a bundle that does not exist.\n    if (locale && locale.includes('_')) {\n        locale = locale.replaceAll('_', '-');\n    }\n    if (isValidLocale(locale) && locale !== document.documentElement.getAttribute('lang')) {\n        document.documentElement.setAttribute('lang', locale);\n    }\n}\nsessionStore.subscribe((state)=>{\n    if (state.loaded && state.session) {\n        setUserLanguage(state.session);\n    }\n});\nfunction userHasPrivilege(requiredPrivilege, user) {\n    if (typeof requiredPrivilege === 'string') {\n        return !isUndefined(user.privileges.find((p)=>requiredPrivilege === p.display));\n    } else if (Array.isArray(requiredPrivilege)) {\n        return requiredPrivilege.every((rp)=>!isUndefined(user.privileges.find((p)=>rp === p.display)));\n    } else if (!isUndefined(requiredPrivilege)) {\n        console.error(`Could not understand privileges \"${requiredPrivilege}\"`);\n    }\n    return true;\n}\nfunction isSuperUser(user) {\n    return !isUndefined(user.roles.find((role)=>role.display === 'System Developer'));\n}\n/**\n * The `refetchCurrentUser` function causes a network request to redownload\n * the user. All subscribers to the session store will be notified of the\n * new user once the new version of the user object is downloaded.\n *\n * If the server rejects the request as unauthenticated (401 or 403), the store records a\n * logged-out session. If the request fails for any other reason, a session that has already\n * loaded is kept; otherwise the store records the error.\n *\n * @returns A Promise resolving to the updated session store state. It rejects with the\n *   store state if the request fails for a reason other than authentication.\n *\n * @example\n * ```js\n * import { refetchCurrentUser } from '@openmrs/esm-api'\n * refetchCurrentUser()\n * ```\n */ export function refetchCurrentUser(username, password) {\n    lastFetchTimeMillis = Date.now();\n    firstFetchTimeMillis ?? (firstFetchTimeMillis = lastFetchTimeMillis);\n    let headers = {};\n    if (username && password) {\n        headers['Authorization'] = `Basic ${window.btoa(`${username}:${password}`)}`;\n    }\n    const refresh = handleSessionResponse(openmrsFetch(sessionEndpoint, {\n        headers,\n        rejectAuthFailure: true\n    }));\n    // Publish the request so that readers can wait on it instead of reading the session it is about to\n    // replace. Each call still issues its own request; this only tracks the most recent one.\n    const clear = ()=>{\n        if (inFlightRefresh === refresh) {\n            inFlightRefresh = null;\n        }\n    };\n    refresh.then(clear, clear);\n    inFlightRefresh = refresh;\n    return refresh;\n}\n/**\n * Clears the current user session from the session store, setting the session\n * to an unauthenticated state. This is typically called during logout to reset\n * the application's authentication state.\n *\n * @example\n * ```ts\n * import { clearCurrentUser } from '@openmrs/esm-api';\n * // During logout\n * clearCurrentUser();\n * ```\n */ export function clearCurrentUser() {\n    sessionStore.setState({\n        loaded: true,\n        session: {\n            authenticated: false,\n            sessionId: ''\n        }\n    }, true);\n}\n/**\n * Checks whether the given user has access based on the required privilege(s).\n * A user has access if they have the required privilege(s) or if they are a\n * \"System Developer\" (super user). If no privilege is required, access is granted.\n *\n * @param requiredPrivilege A single privilege string or an array of privilege strings\n *   that the user must have. If an array is provided, the user must have ALL privileges.\n * @param user The user object containing their privileges and roles.\n * @returns `true` if the user has access, `false` otherwise. Returns `true` if no\n *   privilege is required, and `false` if the user is undefined but a privilege is required.\n *\n * @example\n * ```ts\n * import { userHasAccess } from '@openmrs/esm-api';\n * const hasAccess = userHasAccess('View Patients', currentUser);\n * const hasMultipleAccess = userHasAccess(['View Patients', 'Edit Patients'], currentUser);\n * ```\n */ export function userHasAccess(requiredPrivilege, user) {\n    if (user === undefined) {\n        // if the user hasn't been loaded, then return false iff there is a required privilege\n        return !Boolean(requiredPrivilege);\n    }\n    if (!Boolean(requiredPrivilege)) {\n        // if user exists but no requiredPrivilege is defined\n        return true;\n    }\n    return userHasPrivilege(requiredPrivilege, user) || isSuperUser(user);\n}\n/**\n * Returns a Promise that resolves with the currently logged-in user object.\n * If the user is already loaded in the session store, the Promise resolves immediately.\n * Otherwise, it subscribes to the session store and resolves when a logged-in user\n * becomes available.\n *\n * @returns A Promise that resolves with the LoggedInUser object once available.\n *\n * @example\n * ```ts\n * import { getLoggedInUser } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * console.log('Logged in as:', user.display);\n * ```\n */ export function getLoggedInUser() {\n    let user;\n    let unsubscribe;\n    return new Promise((res)=>{\n        const handler = (state)=>{\n            if (state.loaded && state.session.user) {\n                user = state.session.user;\n                res(state.session.user);\n                if (unsubscribe) {\n                    unsubscribe();\n                }\n            }\n        };\n        handler(sessionStore.getState());\n        if (!user) {\n            unsubscribe = sessionStore.subscribe(handler);\n        }\n    });\n}\n/**\n * Returns a Promise that resolves with the current session location, if one is set.\n * The session location represents the physical location where the user is currently\n * working (e.g., a clinic or ward).\n *\n * @returns A Promise that resolves with the SessionLocation object, or `undefined`\n *   if no session location is set.\n *\n * @example\n * ```ts\n * import { getSessionLocation } from '@openmrs/esm-api';\n * const location = await getSessionLocation();\n * if (location) {\n *   console.log('Current location:', location.display);\n * }\n * ```\n */ export async function getSessionLocation() {\n    const session = await getCurrentUser();\n    return session.sessionLocation;\n}\n/**\n * Sets the session location for the current user. The session location represents\n * the physical location where the user is working (e.g., a clinic or ward).\n * This triggers a server request to update the session and refreshes the local\n * session store.\n *\n * @param locationUuid The UUID of the location to set as the session location.\n * @param abortController An AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore.\n *\n * @example\n * ```ts\n * import { setSessionLocation } from '@openmrs/esm-api';\n * const abortController = new AbortController();\n * await setSessionLocation('location-uuid-here', abortController);\n * ```\n */ export async function setSessionLocation(locationUuid, abortController) {\n    return handleSessionResponse(openmrsFetch(sessionEndpoint, {\n        method: 'POST',\n        body: {\n            sessionLocation: locationUuid\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        rejectAuthFailure: true,\n        signal: abortController?.signal\n    }));\n}\n/**\n * Sets the locale for the current session only, leaving the user's default locale unchanged.\n * Use {@link setUserProperties} with a `defaultLocale` property to change the default instead.\n *\n * @param locale The locale in Java's `Locale#toString()` form, e.g. `en_GB`.\n * @param abortController Optional AbortController to allow cancellation of the request.\n * @returns A Promise that resolves with the updated SessionStore after refetching the current user.\n *   It rejects with an {@link OpenmrsFetchError} if the server does not accept the locale.\n *\n * @example\n * ```ts\n * import { setSessionLocale } from '@openmrs/esm-api';\n * await setSessionLocale('fr');\n * ```\n *\n * @internal\n */ export async function setSessionLocale(locale, abortController) {\n    await openmrsFetch(sessionEndpoint, {\n        method: 'POST',\n        body: {\n            locale\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController?.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Updates the user properties for a specific user. User properties are key-value\n * pairs that store user-specific settings and preferences. After updating the\n * properties on the server, the current user session is refetched to reflect\n * the changes.\n *\n * @param userUuid The UUID of the user whose properties should be updated.\n * @param userProperties An object containing the properties to set or update.\n * @param abortController Optional AbortController to allow cancellation of the request.\n *   If not provided, a new AbortController is created.\n * @returns A Promise that resolves with the updated SessionStore after refetching\n *   the current user.\n *\n * @example\n * ```ts\n * import { getLoggedInUser, setUserProperties } from '@openmrs/esm-api';\n * const user = await getLoggedInUser();\n * await setUserProperties(user.uuid, {\n *   defaultLocale: 'en_GB',\n *   customSetting: 'value'\n * });\n * ```\n */ export async function setUserProperties(userUuid, userProperties, abortController) {\n    if (!abortController) {\n        abortController = new AbortController();\n    }\n    await openmrsFetch(`${restBaseUrl}/user/${userUuid}`, {\n        method: 'POST',\n        body: {\n            userProperties\n        },\n        headers: {\n            'Content-Type': 'application/json'\n        },\n        signal: abortController.signal\n    });\n    return refetchCurrentUser();\n}\n/**\n * Submits a TOTP code to complete a two-factor login challenge. When the code is accepted, the\n * session store is refreshed with the now-authenticated session.\n *\n * @param code The code from the user's authenticator app.\n * @param rememberDevice Whether the server should skip the challenge on this device in future.\n * @returns A Promise resolving to the session. Its `authenticated` property is `false` if the\n *   code was not accepted. It rejects with an {@link OpenmrsFetchError} if the server rejects the\n *   request, in which case `responseBody` may explain why.\n *\n * @example\n * ```ts\n * import { verifyTotpCode } from '@openmrs/esm-api';\n * const session = await verifyTotpCode('123456', true);\n * ```\n *\n * @internal\n */ export async function verifyTotpCode(code, rememberDevice = false) {\n    const response = await openmrsFetch(rememberDevice ? `${sessionEndpoint}?rememberMe=true` : sessionEndpoint, {\n        headers: {\n            'X-Totp-Code': code\n        }\n    });\n    if (response.data?.authenticated) {\n        // `refetchCurrentUser` only resolves once the store holds a session.\n        const store = await refetchCurrentUser();\n        return store.session;\n    }\n    return response.data;\n}\n/**\n * Ends the current session on the server and records a logged-out session in the session store.\n * A server that has already ended the session (401 or 403) counts as a successful logout.\n *\n * Other data cached for the logged-in user, such as SWR caches, is the caller's to clear.\n *\n * @returns A Promise that resolves once the session store holds a logged-out session.\n *\n * @example\n * ```ts\n * import { logout } from '@openmrs/esm-api';\n * await logout();\n * ```\n *\n * @internal\n */ export async function logout() {\n    try {\n        await openmrsFetch(sessionEndpoint, {\n            method: 'DELETE',\n            rejectAuthFailure: true\n        });\n    } catch (err) {\n        if (!isAuthFailure(err)) {\n            throw err;\n        }\n    }\n    clearCurrentUser();\n    // The session just cleared is already correct, so a failed refresh loses nothing.\n    await refetchCurrentUser().catch(()=>{});\n}\nfunction handleSessionResponse(result) {\n    return new Promise((resolve, reject)=>{\n        result.then((res)=>{\n            if (typeof res?.data === 'object') {\n                const nextState = {\n                    loaded: true,\n                    session: res.data\n                };\n                sessionStore.setState(nextState, true);\n                resolve(nextState);\n            } else if (isInitialSetupRedirect(res)) {\n                reject(recordSessionFailure(Error('The server is still starting up'), true));\n            } else {\n                reject(recordSessionFailure(Error('The session endpoint did not respond with a session')));\n            }\n        }).catch((err)=>{\n            // An auth failure is the session endpoint's answer for \"not logged in\", not a failed lookup.\n            if (isAuthFailure(err)) {\n                if (isUnauthenticatedSession(err.responseBody)) {\n                    sessionStore.setState({\n                        loaded: true,\n                        session: err.responseBody\n                    }, true);\n                } else {\n                    clearCurrentUser();\n                }\n                resolve(sessionStore.getState());\n                return;\n            }\n            if (isGatewayErrorDuringStartup(err)) {\n                reject(recordSessionFailure(err, true));\n                return;\n            }\n            reportError(`Failed to fetch new session information: ${err}`);\n            reject(recordSessionFailure(err));\n        });\n    });\n}\nfunction isAuthFailure(err) {\n    return err instanceof OpenmrsFetchError && (err.response.status === 401 || err.response.status === 403);\n}\n/**\n * Until the backend has finished its initial setup, it answers every request with a redirect to its\n * setup page, which `fetch()` follows, so the session request resolves with that page's HTML.\n */ function isInitialSetupRedirect(res) {\n    if (!res?.redirected || !res.url) {\n        return false;\n    }\n    try {\n        return new URL(res.url, window.location.href).pathname.replace(/\\/+$/, '').endsWith('/initialsetup');\n    } catch  {\n        return false;\n    }\n}\nfunction isGatewayErrorDuringStartup(err) {\n    return err instanceof OpenmrsFetchError && err.response.status === 502 && !sessionStore.getState().loaded && firstFetchTimeMillis !== undefined && Date.now() - firstFetchTimeMillis < startupGracePeriodMillis;\n}\nfunction isUnauthenticatedSession(body) {\n    return typeof body === 'object' && body !== null && body.authenticated === false;\n}\n/**\n * A session that has already loaded is kept when a later fetch fails, since it is still the best answer\n * available. With nothing to fall back on, the error is recorded so the app shell can show an error page.\n */ function recordSessionFailure(err, initializing = false) {\n    if (!sessionStore.getState().loaded) {\n        sessionStore.setState({\n            loaded: false,\n            session: null,\n            error: err instanceof Error ? err : Error(String(err)),\n            initializing\n        }, true);\n    }\n    return sessionStore.getState();\n}\n"],"names":["reportError","createGlobalStore","isUndefined","OpenmrsFetchError","openmrsFetch","restBaseUrl","sessionEndpoint","sessionStore","sessionMaxAgeMillis","lastFetchTimeMillis","startupGracePeriodMillis","firstFetchTimeMillis","inFlightRefresh","refreshSessionIfStale","Date","refetchCurrentUser","getCurrentUser","opts","includeAuthStatus","select","session","refresh","Promise","resolve","resolveIfLoaded","state","unsubscribe","getSessionStore","isValidLocale","locale","undefined","Intl","e","setUserLanguage","data","document","userHasPrivilege","requiredPrivilege","user","p","Array","rp","console","isSuperUser","role","username","password","headers","window","handleSessionResponse","clear","clearCurrentUser","userHasAccess","Boolean","getLoggedInUser","res","handler","getSessionLocation","setSessionLocation","locationUuid","abortController","setSessionLocale","setUserProperties","userUuid","userProperties","AbortController","verifyTotpCode","code","rememberDevice","response","store","logout","err","isAuthFailure","result","reject","nextState","isInitialSetupRedirect","recordSessionFailure","Error","isUnauthenticatedSession","isGatewayErrorDuringStartup","URL","body","initializing","String"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,0BAA0B,GAA6D;AAChC;AACf;AAC2D;AACnG,cAAc,GAAU,MAAMO,eAAeN,yDAAiBA,CAAC,WAAW;IACtE,QAAQ;IACR,SAAS;AACb,GAAG;AACH;;;;CAIC,GAAG,MAAMO,sBAAsB,KAAK;AACrC,IAAIC,sBAAsB;AAC1B;;;CAGC,GAAG,MAAMC,2BAA2B,IAAI,KAAK;AAC9C,IAAIC;AACJ,IAAIC,kBAAkB;AACtB;;;;;;;;;;;CAWC,GAAG,SAASC;IACT,IAAID,iBAAiB;QACjB,OAAOA;IACX;IACA,IAAIL,aAAa,QAAQ,GAAG,MAAM,IAAIE,uBAAuBK,KAAK,GAAG,KAAKN,qBAAqB;QAC3F,OAAO;IACX;IACA,OAAOO;AACX;AACA,SAASC,eAAeC,IAAI;IACxB,MAAMC,oBAAoBD,MAAM,qBAAqB;IACrD,MAAME,SAAS,CAACC,UAAUF,oBAAoBE,UAAUA,QAAQ,IAAI;IACpE,MAAMC,UAAUR;IAChB,IAAI,CAACQ,SAAS;QACV,OAAOC,QAAQ,OAAO,CAACH,OAAOZ,aAAa,QAAQ,GAAG,OAAO;IACjE;IACA,OAAO,IAAIe,QAAQ,CAACC;QAChB,MAAMC,kBAAkB;YACpB,MAAMC,QAAQlB,aAAa,QAAQ;YACnC,IAAIkB,MAAM,MAAM,EAAE;gBACdC;gBACAH,QAAQJ,OAAOM,MAAM,OAAO;YAChC;QACJ;QACA,MAAMC,cAAcnB,aAAa,SAAS,CAACiB;QAC3C,sFAAsF;QACtF,uCAAuC;QACvCH,QAAQ,IAAI,CAACG,iBAAiBA;IAClC;AACJ;AAC0B;AAC1B;;;;;;;;;;;;;;;;;CAiBC,GAAU,SAASG;IAChBd;IACA,OAAON;AACX;AACA,gDAAgD;AAChD,SAASqB,cAAcC,MAAM;IACzB,IAAIA,WAAWC,aAAa,OAAOD,WAAW,UAAU;QACpD,OAAO;IACX;IACA,IAAI;QACA,IAAIE,KAAK,MAAM,CAACF;IACpB,EAAE,OAAOG,GAAG;QACR,OAAO;IACX;IACA,OAAO;AACX;AACA;;;;;;;;;;CAUC,GAAU,SAASC,gBAAgBC,IAAI;IACpC,IAAIL,SAASK,KAAK,MAAM,IAAIA,KAAK,IAAI,EAAE,gBAAgB;IACvD,kGAAkG;IAClG,iGAAiG;IACjG,kGAAkG;IAClG,sCAAsC;IACtC,IAAIL,UAAUA,OAAO,QAAQ,CAAC,MAAM;QAChCA,SAASA,OAAO,UAAU,CAAC,KAAK;IACpC;IACA,IAAID,cAAcC,WAAWA,WAAWM,SAAS,eAAe,CAAC,YAAY,CAAC,SAAS;QACnFA,SAAS,eAAe,CAAC,YAAY,CAAC,QAAQN;IAClD;AACJ;AACAtB,aAAa,SAAS,CAAC,CAACkB;IACpB,IAAIA,MAAM,MAAM,IAAIA,MAAM,OAAO,EAAE;QAC/BQ,gBAAgBR,MAAM,OAAO;IACjC;AACJ;AACA,SAASW,iBAAiBC,iBAAiB,EAAEC,IAAI;IAC7C,IAAI,OAAOD,sBAAsB,UAAU;QACvC,OAAO,CAACnC,yCAAWA,CAACoC,KAAK,UAAU,CAAC,IAAI,CAAC,CAACC,IAAIF,sBAAsBE,EAAE,OAAO;IACjF,OAAO,IAAIC,MAAM,OAAO,CAACH,oBAAoB;QACzC,OAAOA,kBAAkB,KAAK,CAAC,CAACI,KAAK,CAACvC,yCAAWA,CAACoC,KAAK,UAAU,CAAC,IAAI,CAAC,CAACC,IAAIE,OAAOF,EAAE,OAAO;IAChG,OAAO,IAAI,CAACrC,yCAAWA,CAACmC,oBAAoB;QACxCK,QAAQ,KAAK,CAAC,CAAC,iCAAiC,EAAEL,kBAAkB,CAAC,CAAC;IAC1E;IACA,OAAO;AACX;AACA,SAASM,YAAYL,IAAI;IACrB,OAAO,CAACpC,yCAAWA,CAACoC,KAAK,KAAK,CAAC,IAAI,CAAC,CAACM,OAAOA,KAAK,OAAO,KAAK;AACjE;AACA;;;;;;;;;;;;;;;;;CAiBC,GAAU,SAAS7B,mBAAmB8B,QAAQ,EAAEC,QAAQ;IACrDrC,sBAAsBK,KAAK,GAAG;IAC9BH,wBAAyBA,CAAAA,uBAAuBF,mBAAkB;IAClE,IAAIsC,UAAU,CAAC;IACf,IAAIF,YAAYC,UAAU;QACtBC,OAAO,CAAC,gBAAgB,GAAG,CAAC,MAAM,EAAEC,OAAO,IAAI,CAAC,GAAGH,SAAS,CAAC,EAAEC,UAAU,GAAG;IAChF;IACA,MAAMzB,UAAU4B,sBAAsB7C,mDAAYA,CAACE,kDAAeA,EAAE;QAChEyC;QACA,mBAAmB;IACvB;IACA,mGAAmG;IACnG,yFAAyF;IACzF,MAAMG,QAAQ;QACV,IAAItC,oBAAoBS,SAAS;YAC7BT,kBAAkB;QACtB;IACJ;IACAS,QAAQ,IAAI,CAAC6B,OAAOA;IACpBtC,kBAAkBS;IAClB,OAAOA;AACX;AACA;;;;;;;;;;;CAWC,GAAU,SAAS8B;IAChB5C,aAAa,QAAQ,CAAC;QAClB,QAAQ;QACR,SAAS;YACL,eAAe;YACf,WAAW;QACf;IACJ,GAAG;AACP;AACA;;;;;;;;;;;;;;;;;CAiBC,GAAU,SAAS6C,cAAcf,iBAAiB,EAAEC,IAAI;IACrD,IAAIA,SAASR,WAAW;QACpB,sFAAsF;QACtF,OAAO,CAACuB,QAAQhB;IACpB;IACA,IAAI,CAACgB,QAAQhB,oBAAoB;QAC7B,qDAAqD;QACrD,OAAO;IACX;IACA,OAAOD,iBAAiBC,mBAAmBC,SAASK,YAAYL;AACpE;AACA;;;;;;;;;;;;;;CAcC,GAAU,SAASgB;IAChB,IAAIhB;IACJ,IAAIZ;IACJ,OAAO,IAAIJ,QAAQ,CAACiC;QAChB,MAAMC,UAAU,CAAC/B;YACb,IAAIA,MAAM,MAAM,IAAIA,MAAM,OAAO,CAAC,IAAI,EAAE;gBACpCa,OAAOb,MAAM,OAAO,CAAC,IAAI;gBACzB8B,IAAI9B,MAAM,OAAO,CAAC,IAAI;gBACtB,IAAIC,aAAa;oBACbA;gBACJ;YACJ;QACJ;QACA8B,QAAQjD,aAAa,QAAQ;QAC7B,IAAI,CAAC+B,MAAM;YACPZ,cAAcnB,aAAa,SAAS,CAACiD;QACzC;IACJ;AACJ;AACA;;;;;;;;;;;;;;;;CAgBC,GAAU,eAAeC;IACtB,MAAMrC,UAAU,MAAMJ;IACtB,OAAOI,QAAQ,eAAe;AAClC;AACA;;;;;;;;;;;;;;;;CAgBC,GAAU,eAAesC,mBAAmBC,YAAY,EAAEC,eAAe;IACtE,OAAOX,sBAAsB7C,mDAAYA,CAACE,kDAAeA,EAAE;QACvD,QAAQ;QACR,MAAM;YACF,iBAAiBqD;QACrB;QACA,SAAS;YACL,gBAAgB;QACpB;QACA,mBAAmB;QACnB,QAAQC,iBAAiB;IAC7B;AACJ;AACA;;;;;;;;;;;;;;;;CAgBC,GAAU,eAAeC,iBAAiBhC,MAAM,EAAE+B,eAAe;IAC9D,MAAMxD,mDAAYA,CAACE,kDAAeA,EAAE;QAChC,QAAQ;QACR,MAAM;YACFuB;QACJ;QACA,SAAS;YACL,gBAAgB;QACpB;QACA,QAAQ+B,iBAAiB;IAC7B;IACA,OAAO7C;AACX;AACA;;;;;;;;;;;;;;;;;;;;;;CAsBC,GAAU,eAAe+C,kBAAkBC,QAAQ,EAAEC,cAAc,EAAEJ,eAAe;IACjF,IAAI,CAACA,iBAAiB;QAClBA,kBAAkB,IAAIK;IAC1B;IACA,MAAM7D,mDAAYA,CAAC,GAAGC,8CAAWA,CAAC,MAAM,EAAE0D,UAAU,EAAE;QAClD,QAAQ;QACR,MAAM;YACFC;QACJ;QACA,SAAS;YACL,gBAAgB;QACpB;QACA,QAAQJ,gBAAgB,MAAM;IAClC;IACA,OAAO7C;AACX;AACA;;;;;;;;;;;;;;;;;CAiBC,GAAU,eAAemD,eAAeC,IAAI,EAAEC,iBAAiB,KAAK;IACjE,MAAMC,WAAW,MAAMjE,mDAAYA,CAACgE,iBAAiB,GAAG9D,kDAAeA,CAAC,gBAAgB,CAAC,GAAGA,kDAAeA,EAAE;QACzG,SAAS;YACL,eAAe6D;QACnB;IACJ;IACA,IAAIE,SAAS,IAAI,EAAE,eAAe;QAC9B,qEAAqE;QACrE,MAAMC,QAAQ,MAAMvD;QACpB,OAAOuD,MAAM,OAAO;IACxB;IACA,OAAOD,SAAS,IAAI;AACxB;AACA;;;;;;;;;;;;;;;CAeC,GAAU,eAAeE;IACtB,IAAI;QACA,MAAMnE,mDAAYA,CAACE,kDAAeA,EAAE;YAChC,QAAQ;YACR,mBAAmB;QACvB;IACJ,EAAE,OAAOkE,KAAK;QACV,IAAI,CAACC,cAAcD,MAAM;YACrB,MAAMA;QACV;IACJ;IACArB;IACA,kFAAkF;IAClF,MAAMpC,qBAAqB,KAAK,CAAC,KAAK;AAC1C;AACA,SAASkC,sBAAsByB,MAAM;IACjC,OAAO,IAAIpD,QAAQ,CAACC,SAASoD;QACzBD,OAAO,IAAI,CAAC,CAACnB;YACT,IAAI,OAAOA,KAAK,SAAS,UAAU;gBAC/B,MAAMqB,YAAY;oBACd,QAAQ;oBACR,SAASrB,IAAI,IAAI;gBACrB;gBACAhD,aAAa,QAAQ,CAACqE,WAAW;gBACjCrD,QAAQqD;YACZ,OAAO,IAAIC,uBAAuBtB,MAAM;gBACpCoB,OAAOG,qBAAqBC,MAAM,oCAAoC;YAC1E,OAAO;gBACHJ,OAAOG,qBAAqBC,MAAM;YACtC;QACJ,GAAG,KAAK,CAAC,CAACP;YACN,6FAA6F;YAC7F,IAAIC,cAAcD,MAAM;gBACpB,IAAIQ,yBAAyBR,IAAI,YAAY,GAAG;oBAC5CjE,aAAa,QAAQ,CAAC;wBAClB,QAAQ;wBACR,SAASiE,IAAI,YAAY;oBAC7B,GAAG;gBACP,OAAO;oBACHrB;gBACJ;gBACA5B,QAAQhB,aAAa,QAAQ;gBAC7B;YACJ;YACA,IAAI0E,4BAA4BT,MAAM;gBAClCG,OAAOG,qBAAqBN,KAAK;gBACjC;YACJ;YACAxE,4DAAWA,CAAC,CAAC,yCAAyC,EAAEwE,KAAK;YAC7DG,OAAOG,qBAAqBN;QAChC;IACJ;AACJ;AACA,SAASC,cAAcD,GAAG;IACtB,OAAOA,eAAerE,oDAAiBA,IAAKqE,CAAAA,IAAI,QAAQ,CAAC,MAAM,KAAK,OAAOA,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAE;AACzG;AACA;;;CAGC,GAAG,SAASK,uBAAuBtB,GAAG;IACnC,IAAI,CAACA,KAAK,cAAc,CAACA,IAAI,GAAG,EAAE;QAC9B,OAAO;IACX;IACA,IAAI;QACA,OAAO,IAAI2B,IAAI3B,IAAI,GAAG,EAAEP,OAAO,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,QAAQ,IAAI,QAAQ,CAAC;IACxF,EAAE,OAAO;QACL,OAAO;IACX;AACJ;AACA,SAASiC,4BAA4BT,GAAG;IACpC,OAAOA,eAAerE,oDAAiBA,IAAIqE,IAAI,QAAQ,CAAC,MAAM,KAAK,OAAO,CAACjE,aAAa,QAAQ,GAAG,MAAM,IAAII,yBAAyBmB,aAAahB,KAAK,GAAG,KAAKH,uBAAuBD;AAC3L;AACA,SAASsE,yBAAyBG,IAAI;IAClC,OAAO,OAAOA,SAAS,YAAYA,SAAS,QAAQA,KAAK,aAAa,KAAK;AAC/E;AACA;;;CAGC,GAAG,SAASL,qBAAqBN,GAAG,EAAEY,eAAe,KAAK;IACvD,IAAI,CAAC7E,aAAa,QAAQ,GAAG,MAAM,EAAE;QACjCA,aAAa,QAAQ,CAAC;YAClB,QAAQ;YACR,SAAS;YACT,OAAOiE,eAAeO,QAAQP,MAAMO,MAAMM,OAAOb;YACjDY;QACJ,GAAG;IACP;IACA,OAAO7E,aAAa,QAAQ;AAChC"}\n//# sourceURL=webpack-internal:///../../framework/esm-api/dist/current-user.js\n\n}");
 
 },
 "../../framework/esm-api/dist/environment.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
@@ -4521,7 +4521,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
 },
 "../../framework/esm-config/dist/module-config/module-config.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  clearConfigErrors: () => (clearConfigErrors),\n  defineConfigSchema: () => (defineConfigSchema),\n  defineExtensionConfigSchema: () => (defineExtensionConfigSchema),\n  getConfig: () => (getConfig),\n  getTranslationOverrides: () => (getTranslationOverrides),\n  processConfig: () => (processConfig),\n  provide: () => (provide),\n  registerModuleLoad: () => (registerModuleLoad),\n  registerModuleWithConfigSystem: () => (registerModuleWithConfigSystem),\n  registerTranslationNamespace: () => (registerTranslationNamespace),\n  resetConfigSystem: () => (resetConfigSystem)\n});\n/* import */ var lodash_es__rspack_import_4 = __webpack_require__(\"../../../node_modules/lodash-es/mergeWith.js\");\n/* import */ var lodash_es__rspack_import_5 = __webpack_require__(\"../../../node_modules/lodash-es/isEqual.js\");\n/* import */ var lodash_es__rspack_import_6 = __webpack_require__(\"../../../node_modules/lodash-es/omit.js\");\n/* import */ var lodash_es__rspack_import_7 = __webpack_require__(\"../../../node_modules/lodash-es/cloneDeep.js\");\n/* import */ var _types_js__rspack_import_0 = __webpack_require__(\"../../framework/esm-config/dist/types.js\");\n/* import */ var _validators_type_validators_js__rspack_import_1 = __webpack_require__(\"../../framework/esm-config/dist/validators/type-validators.js\");\n/* import */ var _validators_validator_js__rspack_import_2 = __webpack_require__(\"../../framework/esm-config/dist/validators/validator.js\");\n/* import */ var _state_js__rspack_import_3 = __webpack_require__(\"../../framework/esm-config/dist/module-config/state.js\");\n/** @module @category Config */ \n\n\n\n\n/**\n * Deep merge two objects, with right-side values taking precedence.\n * Arrays are replaced entirely (not merged by index), matching the\n * behavior of ramda's mergeDeepRight.\n */ function replaceArrays(_objValue, srcValue) {\n    if (Array.isArray(srcValue)) {\n        return srcValue;\n    }\n}\nfunction mergeDeepReplace(left, right) {\n    return (0,lodash_es__rspack_import_4[\"default\"])({}, left, right, replaceArrays);\n}\n/**\n * Store setup\n *\n *\n * Set up stores and subscriptions so that inputs get processed appropriately.\n *\n * There are *input* stores and *output* stores. The *input* stores\n * are configInternalStore, temporaryConfigStore, and configExtensionStore. The\n * output stores are set in the `compute...` functions. They are the module\n * config stores, the extension slot config stores (by module), the extension\n * config stores, and the implementer tools config store.\n *\n * This code sets up the subscriptions so that when an input store changes,\n * the correct set of output stores are updated.\n *\n * All `compute...` functions except `computeExtensionConfigs` are pure\n * (or are supposed to be), other than the fact that they all `setState`\n * store values at the end. `computeExtensionConfigs` calls `getGlobalStore`,\n * which creates stores.\n */ // Store unsubscribe functions to allow cleanup (e.g., in tests or hot module reloading)\nconst configSubscriptions = [];\n/**\n * Recomputes all configuration derived stores based on current state of input stores.\n * Called whenever any input store (configInternalStore, temporaryConfigStore, configExtensionStore) changes.\n */ function recomputeAllConfigs() {\n    const configState = _state_js__rspack_import_3.configInternalStore.getState();\n    const tempConfigState = _state_js__rspack_import_3.temporaryConfigStore.getState();\n    const extensionState = _state_js__rspack_import_3.configExtensionStore.getState();\n    computeModuleConfig(configState, tempConfigState);\n    const slotConfigs = getExtensionSlotConfigs(configState, tempConfigState);\n    computeExtensionSlotConfigs(slotConfigs);\n    computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs);\n    // Last, because a failure here must not skip the outputs above. Only kept current while the\n    // implementer tools are watching it; otherwise derived on read.\n    (0,_state_js__rspack_import_3.invalidateImplementerToolsConfig)();\n}\nfunction setupConfigSubscriptions() {\n    // Registered here rather than at module load so that `resetConfigSystem` restores it.\n    (0,_state_js__rspack_import_3.setImplementerToolsConfigRecomputer)(()=>computeImplementerToolsConfig(_state_js__rspack_import_3.configInternalStore.getState(), _state_js__rspack_import_3.temporaryConfigStore.getState()));\n    // Initial computation\n    recomputeAllConfigs();\n    // Subscribe to all input stores with a single handler\n    // This ensures we only recompute once even if multiple stores change simultaneously\n    configSubscriptions.push(_state_js__rspack_import_3.configInternalStore.subscribe(recomputeAllConfigsSafely), _state_js__rspack_import_3.temporaryConfigStore.subscribe(recomputeAllConfigsSafely), _state_js__rspack_import_3.configExtensionStore.subscribe(recomputeAllConfigsSafely));\n}\n/** Ensure that we do not throw during a store subscription */ function recomputeAllConfigsSafely() {\n    (0,_state_js__rspack_import_3.clearConfigDerivationError)();\n    try {\n        recomputeAllConfigs();\n    } catch (e) {\n        (0,_state_js__rspack_import_3.recordConfigDerivationError)(e);\n        console.error('Failed to recompute the configuration', e);\n    }\n}\n// Set up subscriptions at module load time\nsetupConfigSubscriptions();\nconst moduleConfigCache = new Map();\nfunction computeModuleConfig(state, tempState) {\n    for (let moduleName of Object.keys(state.schemas)){\n        // At this point the schema could be either just the implicit schema or the actually\n        // defined schema. We run with just the implicit schema because we want to populate\n        // the config store with the translation overrides as soon as possible. In fact, the\n        // translation system will throw for Suspense until the translation overrides are\n        // available, which as of this writing blocks the schema definition from occurring\n        // for modules loaded based on their extensions.\n        const moduleStore = (0,_state_js__rspack_import_3.getConfigStore)(moduleName);\n        const schema = state.schemas[moduleName];\n        const moduleLoaded = Boolean(state.moduleLoaded[moduleName]);\n        const cached = moduleConfigCache.get(moduleName);\n        let newState;\n        if (cached && cached.schema === schema && cached.moduleLoaded === moduleLoaded && cached.providedConfigs === state.providedConfigs && cached.temporaryConfig === tempState.config) {\n            newState = cached.state;\n        } else {\n            const config = moduleLoaded ? getConfigForModule(moduleName, state, tempState) : getConfigForModuleImplicitSchema(moduleName, state, tempState);\n            newState = {\n                translationOverridesLoaded: true,\n                loaded: moduleLoaded,\n                config\n            };\n            moduleConfigCache.set(moduleName, {\n                schema,\n                moduleLoaded,\n                providedConfigs: state.providedConfigs,\n                temporaryConfig: tempState.config,\n                state: newState\n            });\n        }\n        // Writing unconditionally would hand every `useConfig` consumer in the application a new\n        // object — and a re-render — whenever any module or extension anywhere is loaded.\n        const oldState = moduleStore.getState();\n        if (oldState.loaded !== newState.loaded || oldState.translationOverridesLoaded !== newState.translationOverridesLoaded || !(0,lodash_es__rspack_import_5[\"default\"])(oldState.config, newState.config)) {\n            moduleStore.setState(newState);\n        }\n    }\n}\nfunction computeExtensionSlotConfigs(slotConfigs) {\n    const slotStore = (0,_state_js__rspack_import_3.getExtensionSlotsConfigStore)();\n    const oldSlots = slotStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    for (const [slotName, config] of Object.entries(slotConfigs)){\n        const previous = oldSlots[slotName];\n        // Entries keep their identity when the configuration behind them hasn't changed, so that\n        // changing one slot's configuration doesn't invalidate every other configured slot.\n        if (previous?.loaded && (0,lodash_es__rspack_import_5[\"default\"])(previous.config, config)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                loaded: true,\n                config\n            };\n            changed = true;\n        }\n    }\n    // Built from scratch rather than merged over the previous state: a slot whose configuration\n    // has been removed — clearing the temporary config, say — has to lose its entry, or the old\n    // configuration stays in force until the page is reloaded.\n    if (changed || Object.keys(oldSlots).length !== Object.keys(slots).length) {\n        slotStore.setState({\n            slots\n        });\n    }\n}\nfunction computeImplementerToolsConfig(state, tempConfigState) {\n    const oldState = _state_js__rspack_import_3.implementerToolsConfigStore.getState();\n    const config = getImplementerToolsConfig(state, tempConfigState);\n    const newState = {\n        config\n    };\n    // Use deep equality on the actual config content, not the wrapper object\n    if (!(0,lodash_es__rspack_import_5[\"default\"])(oldState.config, newState.config)) {\n        _state_js__rspack_import_3.implementerToolsConfigStore.setState(newState);\n    }\n}\nfunction computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs) {\n    const extensionsConfigStore = (0,_state_js__rspack_import_3.getExtensionsConfigStore)();\n    const oldConfigs = extensionsConfigStore.getState().configs;\n    const configs = {};\n    let changed = false;\n    let entryCount = 0;\n    // We assume that the module schema has already been defined, since the extension\n    // it contains is mounted.\n    for (let extension of extensionState.mountedExtensions){\n        const config = computeExtensionConfig(extension.slotModuleName, extension.extensionModuleName, extension.slotName, extension.extensionId, configState, tempConfigState, slotConfigs[extension.slotName]);\n        const previous = oldConfigs[extension.slotName]?.[extension.extensionId];\n        // Entries keep their identity when the configuration behind them hasn't changed, so that\n        // mounting one extension doesn't hand every other mounted extension a new config object.\n        const entry = previous?.loaded && (0,lodash_es__rspack_import_5[\"default\"])(previous.config, config) ? previous : {\n            config,\n            loaded: true\n        };\n        if (entry !== previous) {\n            changed = true;\n        }\n        if (!configs[extension.slotName]) {\n            configs[extension.slotName] = {};\n        }\n        configs[extension.slotName][extension.extensionId] = entry;\n        entryCount++;\n    }\n    // Slots keep their identity too when none of their entries changed. Subscribers compare these\n    // per-slot objects to work out which slots to re-derive, so handing out a fresh one for every\n    // slot on every write would mark every slot with a mounted extension dirty.\n    for (const [slotName, slotConfigs] of Object.entries(configs)){\n        const previousSlot = oldConfigs[slotName];\n        if (previousSlot && Object.keys(previousSlot).length === Object.keys(slotConfigs).length && Object.entries(slotConfigs).every(([extensionId, entry])=>previousSlot[extensionId] === entry)) {\n            configs[slotName] = previousSlot;\n        }\n    }\n    if (!changed) {\n        // Nothing was added or altered, but an extension may have unmounted, which only shows up as a\n        // missing entry.\n        changed = Object.keys(oldConfigs).length !== Object.keys(configs).length || Object.values(oldConfigs).reduce((total, slot)=>total + Object.keys(slot).length, 0) !== entryCount;\n    }\n    if (changed) {\n        extensionsConfigStore.setState({\n            configs\n        });\n    }\n}\n/*\n * API\n *\n */ /**\n * This defines a configuration schema for a module. The schema tells the\n * configuration system how the module can be configured. It specifies\n * what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param moduleName Name of the module the schema is being defined for. Generally\n *   should be the one in which the `defineConfigSchema` call takes place.\n * @param schema The config schema for the module\n */ function defineConfigSchema(moduleName, schema) {\n    validateConfigSchema(moduleName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: enhancedSchema\n            },\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module exists. This allows config to be\n * processed, while still allowing the extension system to know whether the module has\n * actually had its front bundle executed yet.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ function registerModuleWithConfigSystem(moduleName) {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: implicitConfigSchema\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module has been loaded.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ function registerModuleLoad(moduleName) {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This allows the config system to support translation overrides for namespaces that\n * do not correspond to modules.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param namespace\n */ function registerTranslationNamespace(namespace) {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [namespace]: translationOverridesSchema\n            }\n        }));\n}\n/**\n * This defines a configuration schema for an extension. When a schema is defined\n * for an extension, that extension will receive the configuration corresponding\n * to that schema, rather than the configuration corresponding to the module\n * in which it is defined.\n *\n * The schema tells the configuration system how the module can be configured.\n * It specifies what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param extensionName Name of the extension the schema is being defined for.\n *   Should match the `name` of one of the `extensions` entries defined in\n *   the app's `routes.json` file.\n * @param schema The config schema for the extension\n */ function defineExtensionConfigSchema(extensionName, schema) {\n    validateConfigSchema(extensionName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    const state = _state_js__rspack_import_3.configInternalStore.getState();\n    if (state.schemas[extensionName]) {\n        console.error(`Config schema for extension ${extensionName} already exists. If there are multiple extensions with this same name, one will probably crash.`);\n    }\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [extensionName]: enhancedSchema\n            }\n        }));\n}\n/**\n * Provides configuration values programmatically. This is an alternative to\n * providing configuration through the config-file. Configuration provided this\n * way will be merged with configuration from other sources.\n *\n * @param config A configuration object to merge into the existing configuration.\n * @param sourceName An optional name to identify the source of this configuration,\n *   used for debugging purposes. Defaults to 'provided'.\n */ function provide(config, sourceName = 'provided') {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            providedConfigs: [\n                ...state.providedConfigs,\n                {\n                    source: sourceName,\n                    config\n                }\n            ]\n        }));\n}\n/**\n * Resolves with `select(state)` as soon as the store's state satisfies `ready`, leaving no\n * subscription behind: nothing subscribes at all when the store is already ready. That matters\n * because `getConfig` runs on every HTTP request, and a subscription that outlives its promise\n * both retains its closure forever and slows down every later write to that store.\n */ function whenStoreReady(store, ready, select) {\n    return new Promise((resolve)=>{\n        let unsubscribe;\n        let resolved = false;\n        function update(state) {\n            if (!resolved && ready(state)) {\n                resolved = true;\n                resolve(select(state));\n                unsubscribe?.();\n            }\n        }\n        update(store.getState());\n        if (!resolved) {\n            unsubscribe = store.subscribe(update);\n        }\n    });\n}\n/**\n * A promise-based way to access the config as soon as it is fully loaded.\n * If it is already loaded, resolves the config in its present state.\n *\n * This is a useful function if you need to get the config in the course\n * of the execution of a function.\n *\n * @param moduleName The name of the module for which to look up the config\n */ function getConfig(moduleName) {\n    return whenStoreReady((0,_state_js__rspack_import_3.getConfigStore)(moduleName), (state)=>Boolean(state.loaded && state.config), (state)=>(0,lodash_es__rspack_import_6[\"default\"])(state.config, [\n            'Display conditions',\n            'Translation overrides'\n        ]));\n}\n/**\n * Retrieves translation overrides for an extension, optionally scoped to a specific\n * extension slot. When called with only a module name, retrieves module-level overrides.\n * Translation overrides allow customizing translated strings without modifying the\n * original translation files.\n *\n * @param moduleName The name of the module providing the translation context.\n * @param slotName Optional extension slot name to include slot-specific overrides.\n * @param extensionId Optional extension ID to include extension-specific overrides.\n * @returns A Promise resolving to an array of translation override objects.\n *\n * @internal\n */ function getTranslationOverrides(moduleName, slotName, extensionId) {\n    const promises = [\n        whenStoreReady((0,_state_js__rspack_import_3.getConfigStore)(moduleName), (state)=>Boolean(state.translationOverridesLoaded && state.config), (state)=>state.config['Translation overrides'] ?? {})\n    ];\n    if (slotName && extensionId) {\n        promises.push(whenStoreReady((0,_state_js__rspack_import_3.getExtensionConfig)(slotName, extensionId), (state)=>Boolean(state.loaded && state.config), (state)=>state.config['Translation overrides'] ?? {}));\n    }\n    return Promise.all(promises);\n}\n/**\n * Validate and interpolate defaults for `providedConfig` according to `schema`\n *\n * @param schema  a configuration schema\n * @param providedConfig  an object of config values (without the top-level module name)\n * @param keyPathContext  a dot-separated string which helps the user figure out where\n *     the provided config came from\n * @returns The validated and processed configuration object with defaults applied.\n * @internal\n */ function processConfig(schema, providedConfig, keyPathContext) {\n    validateStructure(schema, providedConfig, keyPathContext);\n    const config = setDefaults(schema, providedConfig);\n    runAllValidatorsInConfigTree(schema, config, keyPathContext);\n    return config;\n}\nconst extensionConfigCache = new Map();\n/**\n * Returns the configuration for an extension. This configuration is specific\n * to the slot in which it is mounted, and its ID within that slot.\n *\n * The schema for that configuration is the extension schema. If no extension\n * schema has been provided, the schema used is the schema of the module in\n * which the extension is defined.\n *\n * @param slotModuleName The name of the module which defines the extension slot\n * @param extensionModuleName The name of the module which defines the extension (and therefore the config schema)\n * @param slotName The name of the extension slot where the extension is mounted\n * @param extensionId The ID of the extension in its slot\n * @param slotConfig The slot's configuration, gathered from every module that configures it\n */ function computeExtensionConfig(slotModuleName, extensionModuleName, slotName, extensionId, configState, tempConfigState, slotConfig) {\n    const extensionName = getExtensionNameFromId(extensionId);\n    const extensionConfigSchema = configState.schemas[extensionName];\n    // JSON string of these elements should be unique-per-extension\n    const cacheKey = JSON.stringify([\n        slotName,\n        extensionId,\n        slotModuleName,\n        extensionModuleName\n    ]);\n    const cached = extensionConfigCache.get(cacheKey);\n    if (cached && cached.extensionSchema === extensionConfigSchema && cached.extensionModuleSchema === configState.schemas[extensionModuleName] && cached.providedConfigs === configState.providedConfigs && cached.temporaryConfig === tempConfigState.config) {\n        return cached.config;\n    }\n    const nameOfSchemaSource = extensionConfigSchema ? extensionName : extensionModuleName;\n    const providedConfigs = getProvidedConfigs(configState, tempConfigState);\n    const sharedOverride = slotConfig?.configure?.[extensionId] ?? {};\n    const slotModuleConfig = mergeConfigsFor(slotModuleName, providedConfigs);\n    const configOverride = slotModuleConfig?.extensionSlots?.[slotName]?.configure?.[extensionId] ?? {};\n    const extensionConfig = mergeConfigsFor(nameOfSchemaSource, providedConfigs);\n    const combinedConfig = mergeConfigs([\n        extensionConfig,\n        sharedOverride,\n        configOverride\n    ]);\n    const schema = extensionConfigSchema ?? configState.schemas[extensionModuleName];\n    validateStructure(schema, combinedConfig, nameOfSchemaSource);\n    const config = setDefaults(schema, combinedConfig);\n    runAllValidatorsInConfigTree(schema, config, nameOfSchemaSource);\n    delete config.extensionSlots;\n    extensionConfigCache.set(cacheKey, {\n        extensionSchema: extensionConfigSchema,\n        extensionModuleSchema: configState.schemas[extensionModuleName],\n        providedConfigs: configState.providedConfigs,\n        temporaryConfig: tempConfigState.config,\n        config\n    });\n    return config;\n}\nconst implementerToolsModuleCache = new Map();\nfunction getImplementerToolsConfig(configState, tempConfigState) {\n    const annotatedSchemas = getAllSchemasWithValuesAndSources(configState.schemas);\n    const configsAndSources = [\n        ...configState.providedConfigs.map((c)=>[\n                c.config,\n                c.source\n            ]),\n        [\n            tempConfigState.config,\n            'temporary config'\n        ]\n    ];\n    // A module can be configured without having declared a schema, so the module list is the union\n    // of both rather than just the schemas.\n    const moduleNames = new Set(Object.keys(annotatedSchemas));\n    for (const [config] of configsAndSources){\n        for (const moduleName of Object.keys(config)){\n            moduleNames.add(moduleName);\n        }\n    }\n    const result = {};\n    for (const moduleName of moduleNames){\n        const annotatedSchema = annotatedSchemas[moduleName];\n        const configSlices = configsAndSources.map(([config])=>config[moduleName]);\n        const sources = configsAndSources.map(([, source])=>source);\n        const cached = implementerToolsModuleCache.get(moduleName);\n        if (cached && cached.annotatedSchema === annotatedSchema && cached.configSlices.length === configSlices.length && cached.configSlices.every((slice, i)=>slice === configSlices[i]) && cached.sources.every((source, i)=>source === sources[i])) {\n            result[moduleName] = cached.result;\n            continue;\n        }\n        let merged = annotatedSchema ?? {};\n        configsAndSources.forEach(([, source], i)=>{\n            const slice = configSlices[i];\n            if (slice !== undefined) {\n                merged = mergeDeepReplace(merged, createValuesAndSourcesTree(slice, source));\n            }\n        });\n        implementerToolsModuleCache.set(moduleName, {\n            annotatedSchema,\n            configSlices,\n            sources,\n            result: merged\n        });\n        result[moduleName] = merged;\n    }\n    return result;\n}\n/**\n * Caching per module is what stops the walk being quadratic: defining one module's schema\n * recomputes every module.\n *\n * A module with no configuration of its own is published straight from this cache, so nothing may\n * mutate a tree it reads out of the implementer tools config — it is the cache entry.\n */ const schemaValuesAndSourcesCache = new Map();\nfunction getAllSchemasWithValuesAndSources(schemas) {\n    const result = {};\n    for (const [moduleName, schema] of Object.entries(schemas)){\n        const cached = schemaValuesAndSourcesCache.get(moduleName);\n        if (cached && cached.schema === schema) {\n            result[moduleName] = cached.annotated;\n        } else {\n            const annotated = getSchemaWithValuesAndSources((0,lodash_es__rspack_import_7[\"default\"])(schema));\n            schemaValuesAndSourcesCache.set(moduleName, {\n                schema,\n                annotated\n            });\n            result[moduleName] = annotated;\n        }\n    }\n    return result;\n}\nfunction getSchemaWithValuesAndSources(schema) {\n    if (schema.hasOwnProperty('_default')) {\n        return {\n            ...schema,\n            _value: schema._default,\n            _source: 'default'\n        };\n    } else if (isOrdinaryObject(schema)) {\n        return Object.keys(schema).reduce((obj, key)=>{\n            obj[key] = getSchemaWithValuesAndSources(schema[key]);\n            return obj;\n        }, {});\n    } else {\n        // at this point, the schema is bad and an error will have been logged during schema validation\n        return {};\n    }\n}\nfunction createValuesAndSourcesTree(config, source) {\n    if (isOrdinaryObject(config)) {\n        return Object.keys(config).reduce((obj, key)=>{\n            obj[key] = createValuesAndSourcesTree(config[key], source);\n            return obj;\n        }, {});\n    } else {\n        return {\n            _value: config,\n            _source: source\n        };\n    }\n}\nfunction getExtensionSlotConfigs(configState, tempConfigState) {\n    const allConfigs = mergeConfigs(getProvidedConfigs(configState, tempConfigState));\n    const slotConfigPerModule = Object.keys(allConfigs).reduce((obj, key)=>{\n        if (allConfigs[key]?.extensionSlots) {\n            obj[key] = allConfigs[key]?.extensionSlots;\n        }\n        return obj;\n    }, {});\n    validateAllExtensionSlotConfigs(slotConfigPerModule);\n    const slotConfigs = {};\n    const configureBlocks = {};\n    for (const configBySlotName of Object.values(slotConfigPerModule)){\n        for (const [slotName, config] of Object.entries(configBySlotName)){\n            slotConfigs[slotName] = config;\n            if (config.configure) {\n                var _configureBlocks, _slotName;\n                ((_configureBlocks = configureBlocks)[_slotName = slotName] ?? (_configureBlocks[_slotName] = [])).push(config.configure);\n            }\n        }\n    }\n    for (const [slotName, blocks] of Object.entries(configureBlocks)){\n        const configure = blocks.length === 1 ? blocks[0] : mergeConfigs(blocks);\n        if (slotConfigs[slotName].configure !== configure) {\n            slotConfigs[slotName] = {\n                ...slotConfigs[slotName],\n                configure\n            };\n        }\n    }\n    return slotConfigs;\n}\nfunction validateAllExtensionSlotConfigs(slotConfigPerModule) {\n    for (let [moduleName, configBySlotName] of Object.entries(slotConfigPerModule)){\n        for (let [slotName, config] of Object.entries(configBySlotName)){\n            validateExtensionSlotConfig(config, moduleName, slotName);\n        }\n    }\n}\nfunction validateExtensionSlotConfig(config, moduleName, slotName) {\n    const keyPath = `${moduleName}.extensionSlots.${slotName}`;\n    const errorPrefix = `Extension slot config '${keyPath}'`;\n    const invalidKeys = Object.keys(config).filter((k)=>![\n            'add',\n            'remove',\n            'order',\n            'configure'\n        ].includes(k));\n    if (invalidKeys.length) {\n        logError(keyPath, errorPrefix + `' contains invalid keys '${invalidKeys.join(\"', '\")}'`);\n    }\n    if (config.add) {\n        if (!Array.isArray(config.add) || !config.add.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.add' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.remove) {\n        if (!Array.isArray(config.remove) || !config.remove.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.remove' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.order) {\n        if (!Array.isArray(config.order) || !config.order.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.order' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.configure) {\n        if (!isOrdinaryObject(config.configure)) {\n            logError(keyPath, errorPrefix + `.configure' is invalid. Must be an object with extension IDs for keys`);\n        }\n    }\n}\nfunction getProvidedConfigs(configState, tempConfigState) {\n    return [\n        ...configState.providedConfigs.map((c)=>c.config),\n        tempConfigState.config\n    ];\n}\n/**\n * Validates the config schema for a module. Since problems identified here are programming errors\n * that hopefully will be caught during development, this function logs errors to the console directly;\n * it's fine if we spam the user with these errors.\n */ function validateConfigSchema(moduleName, schema, keyPath = '') {\n    const updateMessage = `Please verify that you are running the latest version and, if so, alert the maintainer.`;\n    for (const key of Object.keys(schema).filter((k)=>!k.startsWith('_'))){\n        const thisKeyPath = keyPath + (keyPath && '.') + key;\n        const schemaPart = schema[key];\n        if (thisKeyPath === 'Display conditions') {\n            console.error(`${moduleName} declares a configuration option called \"Display conditions\"; the \"Display conditions\" option is a reserved name. ${updateMessage}`);\n        }\n        if (thisKeyPath === 'Translation overrides') {\n            console.error(`${moduleName} declares a configuration option called \"Translation overrides\"; the \"Translation overrides\" option is a reserved name. ${updateMessage}`);\n        }\n        if (!isOrdinaryObject(schemaPart)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}`);\n            continue;\n        }\n        if (!schemaPart.hasOwnProperty('_default')) {\n            // recurse for nested config keys\n            validateConfigSchema(moduleName, schemaPart, thisKeyPath);\n        }\n        const elements = schemaPart._elements;\n        if (hasObjectSchema(elements)) {\n            validateConfigSchema(moduleName, elements, thisKeyPath + '._elements');\n        }\n        if (schemaPart._validators) {\n            for (let validator of schemaPart._validators){\n                if (typeof validator !== 'function') {\n                    console.error(`${moduleName} has invalid validator for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: validators must be functions that return either ` + `undefined or an error string. Received ${validator}.`);\n                }\n            }\n        }\n        const valueType = schemaPart._type;\n        if (valueType && !Object.values(_types_js__rspack_import_0.Type).includes(valueType)) {\n            console.error(`${moduleName} has invalid type for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: the allowed types are ${Object.values(_types_js__rspack_import_0.Type).join(', ')}. ` + `Received '${valueType}'`);\n        }\n        if (Object.keys(schemaPart).every((k)=>[\n                '_description',\n                '_validators',\n                '_elements',\n                '_type'\n            ].includes(k)) && !keyPath.includes('._elements')) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: all config elements must have a default. ` + `Received ${JSON.stringify(schemaPart)}`);\n        }\n        if (elements && valueType && ![\n            _types_js__rspack_import_0.Type.Array,\n            _types_js__rspack_import_0.Type.Object\n        ].includes(valueType)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: the 'elements' key only works with '_type' equal to 'Array' or 'Object'. ` + `Received ${JSON.stringify(valueType)}`);\n        }\n    }\n}\nfunction getConfigForModule(moduleName, configState, tempConfigState) {\n    const schema = configState.schemas[moduleName];\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    validateStructure(schema, inputConfig, moduleName);\n    const config = setDefaults(schema, inputConfig);\n    runAllValidatorsInConfigTree(schema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction getConfigForModuleImplicitSchema(moduleName, configState, tempConfigState) {\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    const config = setDefaults(implicitConfigSchema, inputConfig);\n    runAllValidatorsInConfigTree(implicitConfigSchema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction mergeConfigsFor(moduleName, allConfigs) {\n    const allConfigsForModule = allConfigs.map(({ [moduleName]: c })=>c).filter((c)=>!!c);\n    return mergeConfigs(allConfigsForModule);\n}\n/**\n * Merges a whole list at once, accumulating into one destination.\n */ function mergeConfigs(configs) {\n    return configs.reduce((acc, config)=>(0,lodash_es__rspack_import_4[\"default\"])(acc, config, replaceArrays), {});\n}\n/**\n * Recursively check the provided config tree to make sure that all\n * of the provided properties exist in the schema, and that types are\n * correct. Does not run validators yet, since those will be run on\n * the config with the defaults filled in.\n */ function validateStructure(schema, config, keyPath = '') {\n    // validate each constituent element\n    for (const key of Object.keys(config)){\n        const value = config[key];\n        const thisKeyPath = keyPath + '.' + key;\n        const schemaPart = schema[key];\n        if (!schema.hasOwnProperty(key)) {\n            if (!(key === 'extensionSlots' && keyPath !== '')) {\n                logError(thisKeyPath, `Unknown config key '${thisKeyPath}' provided. Ignoring.`);\n            }\n            continue;\n        }\n        validateBranchStructure(schemaPart, value, thisKeyPath);\n    }\n}\nfunction validateBranchStructure(schemaPart, value, keyPath) {\n    checkType(keyPath, schemaPart._type, value);\n    if (isOrdinaryObject(value)) {\n        if (schemaPart._type === _types_js__rspack_import_0.Type.Object) {\n            // validate as freeform object\n            validateFreeformObjectStructure(schemaPart, value, keyPath);\n        } else if (!(schemaPart.hasOwnProperty('_default') || schemaPart.hasOwnProperty('_type'))) {\n            // validate as normal nested config\n            validateStructure(schemaPart, value, keyPath);\n        }\n    } else {\n        if (schemaPart._type === _types_js__rspack_import_0.Type.Array) {\n            validateArrayStructure(schemaPart, value, keyPath);\n        }\n    }\n}\nfunction validateFreeformObjectStructure(freeformObjectSchema, config, keyPath) {\n    if (freeformObjectSchema._elements) {\n        for (const key of Object.keys(config)){\n            const value = config[key];\n            validateBranchStructure(freeformObjectSchema._elements, value, `${keyPath}.${key}`);\n        }\n    }\n}\nfunction validateArrayStructure(arraySchema, value, keyPath) {\n    const validatedAsArray = checkType(keyPath, _types_js__rspack_import_0.Type.Array, value);\n    if (!validatedAsArray) {\n        return;\n    }\n    // if there is an array element object schema, verify that elements match it\n    if (hasObjectSchema(arraySchema._elements)) {\n        for(let i = 0; i < value.length; i++){\n            validateBranchStructure(arraySchema._elements, value[i], `${keyPath}[${i}]`);\n        }\n    }\n    for(let i = 0; i < value.length; i++){\n        checkType(`${keyPath}[${i}]`, arraySchema._elements?._type, value[i]);\n    }\n}\n/**\n * Run all the validators in the config tree. This should be run\n * on the config object after it has been filled in with all the defaults, since\n * higher-level validators may refer to default values.\n */ function runAllValidatorsInConfigTree(schema, config, keyPath = '') {\n    // If `!schema`, there should have been a structural validation error printed already.\n    if (schema) {\n        if (config !== schema._default) {\n            runValidators(keyPath, schema._validators, config);\n        }\n        if (isOrdinaryObject(config)) {\n            for (const key of Object.keys(config)){\n                const value = config[key];\n                const thisKeyPath = keyPath + '.' + key;\n                const schemaPart = schema[key];\n                if (schema._type === _types_js__rspack_import_0.Type.Object && schema._elements) {\n                    runAllValidatorsInConfigTree(schema._elements, value, thisKeyPath);\n                } else {\n                    runAllValidatorsInConfigTree(schemaPart, value, thisKeyPath);\n                }\n            }\n        } else if (Array.isArray(config) && schema._elements) {\n            for(let i = 0; i < config.length; i++){\n                runAllValidatorsInConfigTree(schema._elements, config[i], `${keyPath}[${i}]`);\n            }\n        }\n    }\n}\n/**\n * Run type validation for the value, logging any errors.\n * @returns true if validation passes, false otherwise\n */ function checkType(keyPath, _type, value) {\n    if (_type) {\n        const validator = {\n            Array: _validators_type_validators_js__rspack_import_1.isArray,\n            Boolean: _validators_type_validators_js__rspack_import_1.isBoolean,\n            ConceptUuid: _validators_type_validators_js__rspack_import_1.isUuid,\n            Number: _validators_type_validators_js__rspack_import_1.isNumber,\n            Object: _validators_type_validators_js__rspack_import_1.isObject,\n            String: _validators_type_validators_js__rspack_import_1.isString,\n            UUID: _validators_type_validators_js__rspack_import_1.isUuid,\n            PersonAttributeTypeUuid: _validators_type_validators_js__rspack_import_1.isUuid,\n            PatientIdentifierTypeUuid: _validators_type_validators_js__rspack_import_1.isUuid\n        };\n        return runValidators(keyPath, [\n            validator[_type]\n        ], value);\n    }\n    return true;\n}\n/**\n * Runs validators, logging errors.\n * @returns true if all pass, false otherwise.\n */ function runValidators(keyPath, validators, value) {\n    let returnValue = true;\n    if (validators) {\n        try {\n            for (let validator of validators){\n                const validatorResult = validator(value);\n                if (typeof validatorResult === 'string') {\n                    const message = typeof value === 'object' ? `Invalid configuration for ${keyPath}: ${validatorResult}` : `Invalid configuration value ${value} for ${keyPath}: ${validatorResult}`;\n                    logError(keyPath, message);\n                    returnValue = false;\n                }\n            }\n        } catch (e) {\n            console.error(`Skipping invalid validator at \"${keyPath}\". Encountered error\\n\\t${e}`);\n        }\n    }\n    return returnValue;\n}\n// Recursively fill in the config with values from the schema.\nconst setDefaults = (schema, inputConfig)=>{\n    const config = structuredClone(inputConfig);\n    if (!schema) {\n        return config;\n    }\n    for (const key of Object.keys(schema)){\n        const configPart = config[key];\n        const schemaPart = schema[key];\n        // The `schemaPart &&` clause of this `if` statement will only fail\n        // if the schema is very invalid. It is there to prevent the app from\n        // crashing completely, though it will produce unexpected behavior.\n        // If this happens, there should be legible errors in the console from\n        // the schema validator.\n        if (schemaPart && (schemaPart.hasOwnProperty('_type') || schemaPart.hasOwnProperty('_default'))) {\n            // We assume that schemaPart defines a config value, since it has\n            // a property `_type` or `_default`.\n            if (!config.hasOwnProperty(key)) {\n                config[key] = schemaPart['_default'];\n            }\n            // We also check if it is an object or array with object elements, in which case we recurse\n            const elements = schemaPart._elements;\n            if (configPart && hasObjectSchema(elements)) {\n                if (schemaPart._type === _types_js__rspack_import_0.Type.Array && Array.isArray(configPart)) {\n                    const configWithDefaults = configPart.map((conf)=>setDefaults(elements, conf));\n                    config[key] = configWithDefaults;\n                } else if (schemaPart._type === _types_js__rspack_import_0.Type.Object) {\n                    for (let objectKey of Object.keys(configPart)){\n                        configPart[objectKey] = setDefaults(elements, configPart[objectKey]);\n                    }\n                }\n            }\n        } else if (isOrdinaryObject(schemaPart)) {\n            // Since schemaPart has no property \"_type\", if it's an ordinary object\n            // (unlike, importantly, the validators array), we assume it is a parent config property.\n            // We recurse to config[key] and schema[key]. Default config[key] to {}.\n            const selectedConfigPart = configPart ?? {};\n            // There will have been a validation error already if configPart is not a plain object.\n            if (isOrdinaryObject(selectedConfigPart)) {\n                config[key] = setDefaults(schemaPart, selectedConfigPart);\n            }\n        }\n    }\n    return config;\n};\nfunction hasObjectSchema(elementsSchema) {\n    return !!elementsSchema && Object.keys(elementsSchema).filter((e)=>![\n            '_default',\n            '_validators'\n        ].includes(e)).length > 0;\n}\nfunction isOrdinaryObject(value) {\n    return typeof value === 'object' && !Array.isArray(value) && value !== null;\n}\n/** Keep track of which validation errors we have displayed. Each one should only be displayed once. */ let displayedValidationMessages = new Set();\nfunction logError(keyPath, message) {\n    const key = `${keyPath}:::${message}`;\n    // technically, this should not be possible, but because of how things wind-up transpiled, this isn't impossible\n    if (!displayedValidationMessages) {\n        displayedValidationMessages = new Set();\n    }\n    if (!displayedValidationMessages.has(key)) {\n        console.error(message);\n        displayedValidationMessages.add(key);\n    }\n}\n/**\n * Normally, configuration errors are only displayed once. This function clears the list of\n * displayed errors, so that they will be displayed again.\n *\n * @internal\n */ function clearConfigErrors(keyPath) {\n    if (keyPath) {\n        displayedValidationMessages.forEach((key)=>{\n            if (key.startsWith(keyPath)) {\n                displayedValidationMessages.delete(key);\n            }\n        });\n    } else {\n        displayedValidationMessages.clear();\n    }\n}\n/**\n * Cleans up all config store subscriptions and re-establishes them. This is primarily\n * useful for testing, where subscriptions set up at module load time need to be cleared\n * between tests to prevent infinite update loops. After clearing, subscriptions are\n * re-established so the config system continues to work normally.\n *\n * @internal\n */ function resetConfigSystem() {\n    configSubscriptions.forEach((unsubscribe)=>unsubscribe());\n    configSubscriptions.length = 0;\n    // Cached configs are keyed on input identity, so a test that reuses the same schema or config\n    // objects across cases would otherwise be served the previous case's result.\n    moduleConfigCache.clear();\n    extensionConfigCache.clear();\n    schemaValuesAndSourcesCache.clear();\n    implementerToolsModuleCache.clear();\n    setupConfigSubscriptions();\n}\n/**\n * Copied over from esm-extensions. It rightly belongs to that module, but esm-config\n * cannot depend on esm-extensions.\n */ function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\n/**\n * The translation overrides schema is used in the implicit schema given to every module;\n * plus any additional translation namespaces (at time of writing, this is just 'core').\n */ const translationOverridesSchema = {\n    'Translation overrides': {\n        _description: 'Per-language overrides for frontend translations should be keyed by language code and each language dictionary contains the translation key and the display value',\n        _type: _types_js__rspack_import_0.Type.Object,\n        _default: {},\n        _validators: [\n            (0,_validators_validator_js__rspack_import_2.validator)((o)=>Object.keys(o).every((k)=>/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k)), (o)=>{\n                const badKeys = Object.keys(o).filter((k)=>!/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k));\n                return `The 'Translation overrides' object should have language codes for keys. Language codes must be in the form of a two-to-three letter language code optionally followed by a hyphen and a two-to-three letter country code. The following keys do not conform: ${badKeys.join(', ')}.`;\n            })\n        ]\n    }\n};\n/**\n * The implicitConfigSchema is implicitly included in every configuration schema\n */ const implicitConfigSchema = {\n    'Display conditions': {\n        privileges: {\n            _description: 'The privilege(s) the user must have to use this extension',\n            _type: _types_js__rspack_import_0.Type.Array,\n            _default: []\n        },\n        expression: {\n            _description: 'The expression that determines whether the extension is displayed',\n            _type: _types_js__rspack_import_0.Type.String,\n            _default: undefined\n        }\n    },\n    ...translationOverridesSchema\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-config/dist/module-config/module-config.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-config/dist/module-config/module-config.js?c3a5"],"sourcesContent":["/** @module @category Config */ import { cloneDeep, isEqual, mergeWith, omit as lodashOmit } from \"lodash-es\";\nimport { Type } from \"../types.js\";\nimport { isArray, isBoolean, isUuid, isNumber, isObject, isString } from \"../validators/type-validators.js\";\nimport { validator } from \"../validators/validator.js\";\nimport { configExtensionStore, configInternalStore, getConfigStore, getExtensionConfig, getExtensionSlotsConfigStore, getExtensionsConfigStore, clearConfigDerivationError, implementerToolsConfigStore, invalidateImplementerToolsConfig, recordConfigDerivationError, setImplementerToolsConfigRecomputer, temporaryConfigStore } from \"./state.js\";\n/**\n * Deep merge two objects, with right-side values taking precedence.\n * Arrays are replaced entirely (not merged by index), matching the\n * behavior of ramda's mergeDeepRight.\n */ function replaceArrays(_objValue, srcValue) {\n    if (Array.isArray(srcValue)) {\n        return srcValue;\n    }\n}\nfunction mergeDeepReplace(left, right) {\n    return mergeWith({}, left, right, replaceArrays);\n}\n/**\n * Store setup\n *\n *\n * Set up stores and subscriptions so that inputs get processed appropriately.\n *\n * There are *input* stores and *output* stores. The *input* stores\n * are configInternalStore, temporaryConfigStore, and configExtensionStore. The\n * output stores are set in the `compute...` functions. They are the module\n * config stores, the extension slot config stores (by module), the extension\n * config stores, and the implementer tools config store.\n *\n * This code sets up the subscriptions so that when an input store changes,\n * the correct set of output stores are updated.\n *\n * All `compute...` functions except `computeExtensionConfigs` are pure\n * (or are supposed to be), other than the fact that they all `setState`\n * store values at the end. `computeExtensionConfigs` calls `getGlobalStore`,\n * which creates stores.\n */ // Store unsubscribe functions to allow cleanup (e.g., in tests or hot module reloading)\nconst configSubscriptions = [];\n/**\n * Recomputes all configuration derived stores based on current state of input stores.\n * Called whenever any input store (configInternalStore, temporaryConfigStore, configExtensionStore) changes.\n */ function recomputeAllConfigs() {\n    const configState = configInternalStore.getState();\n    const tempConfigState = temporaryConfigStore.getState();\n    const extensionState = configExtensionStore.getState();\n    computeModuleConfig(configState, tempConfigState);\n    const slotConfigs = getExtensionSlotConfigs(configState, tempConfigState);\n    computeExtensionSlotConfigs(slotConfigs);\n    computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs);\n    // Last, because a failure here must not skip the outputs above. Only kept current while the\n    // implementer tools are watching it; otherwise derived on read.\n    invalidateImplementerToolsConfig();\n}\nfunction setupConfigSubscriptions() {\n    // Registered here rather than at module load so that `resetConfigSystem` restores it.\n    setImplementerToolsConfigRecomputer(()=>computeImplementerToolsConfig(configInternalStore.getState(), temporaryConfigStore.getState()));\n    // Initial computation\n    recomputeAllConfigs();\n    // Subscribe to all input stores with a single handler\n    // This ensures we only recompute once even if multiple stores change simultaneously\n    configSubscriptions.push(configInternalStore.subscribe(recomputeAllConfigsSafely), temporaryConfigStore.subscribe(recomputeAllConfigsSafely), configExtensionStore.subscribe(recomputeAllConfigsSafely));\n}\n/** Ensure that we do not throw during a store subscription */ function recomputeAllConfigsSafely() {\n    clearConfigDerivationError();\n    try {\n        recomputeAllConfigs();\n    } catch (e) {\n        recordConfigDerivationError(e);\n        console.error('Failed to recompute the configuration', e);\n    }\n}\n// Set up subscriptions at module load time\nsetupConfigSubscriptions();\nconst moduleConfigCache = new Map();\nfunction computeModuleConfig(state, tempState) {\n    for (let moduleName of Object.keys(state.schemas)){\n        // At this point the schema could be either just the implicit schema or the actually\n        // defined schema. We run with just the implicit schema because we want to populate\n        // the config store with the translation overrides as soon as possible. In fact, the\n        // translation system will throw for Suspense until the translation overrides are\n        // available, which as of this writing blocks the schema definition from occurring\n        // for modules loaded based on their extensions.\n        const moduleStore = getConfigStore(moduleName);\n        const schema = state.schemas[moduleName];\n        const moduleLoaded = Boolean(state.moduleLoaded[moduleName]);\n        const cached = moduleConfigCache.get(moduleName);\n        let newState;\n        if (cached && cached.schema === schema && cached.moduleLoaded === moduleLoaded && cached.providedConfigs === state.providedConfigs && cached.temporaryConfig === tempState.config) {\n            newState = cached.state;\n        } else {\n            const config = moduleLoaded ? getConfigForModule(moduleName, state, tempState) : getConfigForModuleImplicitSchema(moduleName, state, tempState);\n            newState = {\n                translationOverridesLoaded: true,\n                loaded: moduleLoaded,\n                config\n            };\n            moduleConfigCache.set(moduleName, {\n                schema,\n                moduleLoaded,\n                providedConfigs: state.providedConfigs,\n                temporaryConfig: tempState.config,\n                state: newState\n            });\n        }\n        // Writing unconditionally would hand every `useConfig` consumer in the application a new\n        // object — and a re-render — whenever any module or extension anywhere is loaded.\n        const oldState = moduleStore.getState();\n        if (oldState.loaded !== newState.loaded || oldState.translationOverridesLoaded !== newState.translationOverridesLoaded || !isEqual(oldState.config, newState.config)) {\n            moduleStore.setState(newState);\n        }\n    }\n}\nfunction computeExtensionSlotConfigs(slotConfigs) {\n    const slotStore = getExtensionSlotsConfigStore();\n    const oldSlots = slotStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    for (const [slotName, config] of Object.entries(slotConfigs)){\n        const previous = oldSlots[slotName];\n        // Entries keep their identity when the configuration behind them hasn't changed, so that\n        // changing one slot's configuration doesn't invalidate every other configured slot.\n        if (previous?.loaded && isEqual(previous.config, config)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                loaded: true,\n                config\n            };\n            changed = true;\n        }\n    }\n    // Built from scratch rather than merged over the previous state: a slot whose configuration\n    // has been removed — clearing the temporary config, say — has to lose its entry, or the old\n    // configuration stays in force until the page is reloaded.\n    if (changed || Object.keys(oldSlots).length !== Object.keys(slots).length) {\n        slotStore.setState({\n            slots\n        });\n    }\n}\nfunction computeImplementerToolsConfig(state, tempConfigState) {\n    const oldState = implementerToolsConfigStore.getState();\n    const config = getImplementerToolsConfig(state, tempConfigState);\n    const newState = {\n        config\n    };\n    // Use deep equality on the actual config content, not the wrapper object\n    if (!isEqual(oldState.config, newState.config)) {\n        implementerToolsConfigStore.setState(newState);\n    }\n}\nfunction computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs) {\n    const extensionsConfigStore = getExtensionsConfigStore();\n    const oldConfigs = extensionsConfigStore.getState().configs;\n    const configs = {};\n    let changed = false;\n    let entryCount = 0;\n    // We assume that the module schema has already been defined, since the extension\n    // it contains is mounted.\n    for (let extension of extensionState.mountedExtensions){\n        const config = computeExtensionConfig(extension.slotModuleName, extension.extensionModuleName, extension.slotName, extension.extensionId, configState, tempConfigState, slotConfigs[extension.slotName]);\n        const previous = oldConfigs[extension.slotName]?.[extension.extensionId];\n        // Entries keep their identity when the configuration behind them hasn't changed, so that\n        // mounting one extension doesn't hand every other mounted extension a new config object.\n        const entry = previous?.loaded && isEqual(previous.config, config) ? previous : {\n            config,\n            loaded: true\n        };\n        if (entry !== previous) {\n            changed = true;\n        }\n        if (!configs[extension.slotName]) {\n            configs[extension.slotName] = {};\n        }\n        configs[extension.slotName][extension.extensionId] = entry;\n        entryCount++;\n    }\n    // Slots keep their identity too when none of their entries changed. Subscribers compare these\n    // per-slot objects to work out which slots to re-derive, so handing out a fresh one for every\n    // slot on every write would mark every slot with a mounted extension dirty.\n    for (const [slotName, slotConfigs] of Object.entries(configs)){\n        const previousSlot = oldConfigs[slotName];\n        if (previousSlot && Object.keys(previousSlot).length === Object.keys(slotConfigs).length && Object.entries(slotConfigs).every(([extensionId, entry])=>previousSlot[extensionId] === entry)) {\n            configs[slotName] = previousSlot;\n        }\n    }\n    if (!changed) {\n        // Nothing was added or altered, but an extension may have unmounted, which only shows up as a\n        // missing entry.\n        changed = Object.keys(oldConfigs).length !== Object.keys(configs).length || Object.values(oldConfigs).reduce((total, slot)=>total + Object.keys(slot).length, 0) !== entryCount;\n    }\n    if (changed) {\n        extensionsConfigStore.setState({\n            configs\n        });\n    }\n}\n/*\n * API\n *\n */ /**\n * This defines a configuration schema for a module. The schema tells the\n * configuration system how the module can be configured. It specifies\n * what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param moduleName Name of the module the schema is being defined for. Generally\n *   should be the one in which the `defineConfigSchema` call takes place.\n * @param schema The config schema for the module\n */ export function defineConfigSchema(moduleName, schema) {\n    validateConfigSchema(moduleName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: enhancedSchema\n            },\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module exists. This allows config to be\n * processed, while still allowing the extension system to know whether the module has\n * actually had its front bundle executed yet.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ export function registerModuleWithConfigSystem(moduleName) {\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: implicitConfigSchema\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module has been loaded.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ export function registerModuleLoad(moduleName) {\n    configInternalStore.setState((state)=>({\n            ...state,\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This allows the config system to support translation overrides for namespaces that\n * do not correspond to modules.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param namespace\n */ export function registerTranslationNamespace(namespace) {\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [namespace]: translationOverridesSchema\n            }\n        }));\n}\n/**\n * This defines a configuration schema for an extension. When a schema is defined\n * for an extension, that extension will receive the configuration corresponding\n * to that schema, rather than the configuration corresponding to the module\n * in which it is defined.\n *\n * The schema tells the configuration system how the module can be configured.\n * It specifies what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param extensionName Name of the extension the schema is being defined for.\n *   Should match the `name` of one of the `extensions` entries defined in\n *   the app's `routes.json` file.\n * @param schema The config schema for the extension\n */ export function defineExtensionConfigSchema(extensionName, schema) {\n    validateConfigSchema(extensionName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    const state = configInternalStore.getState();\n    if (state.schemas[extensionName]) {\n        console.error(`Config schema for extension ${extensionName} already exists. If there are multiple extensions with this same name, one will probably crash.`);\n    }\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [extensionName]: enhancedSchema\n            }\n        }));\n}\n/**\n * Provides configuration values programmatically. This is an alternative to\n * providing configuration through the config-file. Configuration provided this\n * way will be merged with configuration from other sources.\n *\n * @param config A configuration object to merge into the existing configuration.\n * @param sourceName An optional name to identify the source of this configuration,\n *   used for debugging purposes. Defaults to 'provided'.\n */ export function provide(config, sourceName = 'provided') {\n    configInternalStore.setState((state)=>({\n            ...state,\n            providedConfigs: [\n                ...state.providedConfigs,\n                {\n                    source: sourceName,\n                    config\n                }\n            ]\n        }));\n}\n/**\n * Resolves with `select(state)` as soon as the store's state satisfies `ready`, leaving no\n * subscription behind: nothing subscribes at all when the store is already ready. That matters\n * because `getConfig` runs on every HTTP request, and a subscription that outlives its promise\n * both retains its closure forever and slows down every later write to that store.\n */ function whenStoreReady(store, ready, select) {\n    return new Promise((resolve)=>{\n        let unsubscribe;\n        let resolved = false;\n        function update(state) {\n            if (!resolved && ready(state)) {\n                resolved = true;\n                resolve(select(state));\n                unsubscribe?.();\n            }\n        }\n        update(store.getState());\n        if (!resolved) {\n            unsubscribe = store.subscribe(update);\n        }\n    });\n}\n/**\n * A promise-based way to access the config as soon as it is fully loaded.\n * If it is already loaded, resolves the config in its present state.\n *\n * This is a useful function if you need to get the config in the course\n * of the execution of a function.\n *\n * @param moduleName The name of the module for which to look up the config\n */ export function getConfig(moduleName) {\n    return whenStoreReady(getConfigStore(moduleName), (state)=>Boolean(state.loaded && state.config), (state)=>lodashOmit(state.config, [\n            'Display conditions',\n            'Translation overrides'\n        ]));\n}\n/**\n * Retrieves translation overrides for an extension, optionally scoped to a specific\n * extension slot. When called with only a module name, retrieves module-level overrides.\n * Translation overrides allow customizing translated strings without modifying the\n * original translation files.\n *\n * @param moduleName The name of the module providing the translation context.\n * @param slotName Optional extension slot name to include slot-specific overrides.\n * @param extensionId Optional extension ID to include extension-specific overrides.\n * @returns A Promise resolving to an array of translation override objects.\n *\n * @internal\n */ export function getTranslationOverrides(moduleName, slotName, extensionId) {\n    const promises = [\n        whenStoreReady(getConfigStore(moduleName), (state)=>Boolean(state.translationOverridesLoaded && state.config), (state)=>state.config['Translation overrides'] ?? {})\n    ];\n    if (slotName && extensionId) {\n        promises.push(whenStoreReady(getExtensionConfig(slotName, extensionId), (state)=>Boolean(state.loaded && state.config), (state)=>state.config['Translation overrides'] ?? {}));\n    }\n    return Promise.all(promises);\n}\n/**\n * Validate and interpolate defaults for `providedConfig` according to `schema`\n *\n * @param schema  a configuration schema\n * @param providedConfig  an object of config values (without the top-level module name)\n * @param keyPathContext  a dot-separated string which helps the user figure out where\n *     the provided config came from\n * @returns The validated and processed configuration object with defaults applied.\n * @internal\n */ export function processConfig(schema, providedConfig, keyPathContext) {\n    validateStructure(schema, providedConfig, keyPathContext);\n    const config = setDefaults(schema, providedConfig);\n    runAllValidatorsInConfigTree(schema, config, keyPathContext);\n    return config;\n}\nconst extensionConfigCache = new Map();\n/**\n * Returns the configuration for an extension. This configuration is specific\n * to the slot in which it is mounted, and its ID within that slot.\n *\n * The schema for that configuration is the extension schema. If no extension\n * schema has been provided, the schema used is the schema of the module in\n * which the extension is defined.\n *\n * @param slotModuleName The name of the module which defines the extension slot\n * @param extensionModuleName The name of the module which defines the extension (and therefore the config schema)\n * @param slotName The name of the extension slot where the extension is mounted\n * @param extensionId The ID of the extension in its slot\n * @param slotConfig The slot's configuration, gathered from every module that configures it\n */ function computeExtensionConfig(slotModuleName, extensionModuleName, slotName, extensionId, configState, tempConfigState, slotConfig) {\n    const extensionName = getExtensionNameFromId(extensionId);\n    const extensionConfigSchema = configState.schemas[extensionName];\n    // JSON string of these elements should be unique-per-extension\n    const cacheKey = JSON.stringify([\n        slotName,\n        extensionId,\n        slotModuleName,\n        extensionModuleName\n    ]);\n    const cached = extensionConfigCache.get(cacheKey);\n    if (cached && cached.extensionSchema === extensionConfigSchema && cached.extensionModuleSchema === configState.schemas[extensionModuleName] && cached.providedConfigs === configState.providedConfigs && cached.temporaryConfig === tempConfigState.config) {\n        return cached.config;\n    }\n    const nameOfSchemaSource = extensionConfigSchema ? extensionName : extensionModuleName;\n    const providedConfigs = getProvidedConfigs(configState, tempConfigState);\n    const sharedOverride = slotConfig?.configure?.[extensionId] ?? {};\n    const slotModuleConfig = mergeConfigsFor(slotModuleName, providedConfigs);\n    const configOverride = slotModuleConfig?.extensionSlots?.[slotName]?.configure?.[extensionId] ?? {};\n    const extensionConfig = mergeConfigsFor(nameOfSchemaSource, providedConfigs);\n    const combinedConfig = mergeConfigs([\n        extensionConfig,\n        sharedOverride,\n        configOverride\n    ]);\n    const schema = extensionConfigSchema ?? configState.schemas[extensionModuleName];\n    validateStructure(schema, combinedConfig, nameOfSchemaSource);\n    const config = setDefaults(schema, combinedConfig);\n    runAllValidatorsInConfigTree(schema, config, nameOfSchemaSource);\n    delete config.extensionSlots;\n    extensionConfigCache.set(cacheKey, {\n        extensionSchema: extensionConfigSchema,\n        extensionModuleSchema: configState.schemas[extensionModuleName],\n        providedConfigs: configState.providedConfigs,\n        temporaryConfig: tempConfigState.config,\n        config\n    });\n    return config;\n}\nconst implementerToolsModuleCache = new Map();\nfunction getImplementerToolsConfig(configState, tempConfigState) {\n    const annotatedSchemas = getAllSchemasWithValuesAndSources(configState.schemas);\n    const configsAndSources = [\n        ...configState.providedConfigs.map((c)=>[\n                c.config,\n                c.source\n            ]),\n        [\n            tempConfigState.config,\n            'temporary config'\n        ]\n    ];\n    // A module can be configured without having declared a schema, so the module list is the union\n    // of both rather than just the schemas.\n    const moduleNames = new Set(Object.keys(annotatedSchemas));\n    for (const [config] of configsAndSources){\n        for (const moduleName of Object.keys(config)){\n            moduleNames.add(moduleName);\n        }\n    }\n    const result = {};\n    for (const moduleName of moduleNames){\n        const annotatedSchema = annotatedSchemas[moduleName];\n        const configSlices = configsAndSources.map(([config])=>config[moduleName]);\n        const sources = configsAndSources.map(([, source])=>source);\n        const cached = implementerToolsModuleCache.get(moduleName);\n        if (cached && cached.annotatedSchema === annotatedSchema && cached.configSlices.length === configSlices.length && cached.configSlices.every((slice, i)=>slice === configSlices[i]) && cached.sources.every((source, i)=>source === sources[i])) {\n            result[moduleName] = cached.result;\n            continue;\n        }\n        let merged = annotatedSchema ?? {};\n        configsAndSources.forEach(([, source], i)=>{\n            const slice = configSlices[i];\n            if (slice !== undefined) {\n                merged = mergeDeepReplace(merged, createValuesAndSourcesTree(slice, source));\n            }\n        });\n        implementerToolsModuleCache.set(moduleName, {\n            annotatedSchema,\n            configSlices,\n            sources,\n            result: merged\n        });\n        result[moduleName] = merged;\n    }\n    return result;\n}\n/**\n * Caching per module is what stops the walk being quadratic: defining one module's schema\n * recomputes every module.\n *\n * A module with no configuration of its own is published straight from this cache, so nothing may\n * mutate a tree it reads out of the implementer tools config — it is the cache entry.\n */ const schemaValuesAndSourcesCache = new Map();\nfunction getAllSchemasWithValuesAndSources(schemas) {\n    const result = {};\n    for (const [moduleName, schema] of Object.entries(schemas)){\n        const cached = schemaValuesAndSourcesCache.get(moduleName);\n        if (cached && cached.schema === schema) {\n            result[moduleName] = cached.annotated;\n        } else {\n            const annotated = getSchemaWithValuesAndSources(cloneDeep(schema));\n            schemaValuesAndSourcesCache.set(moduleName, {\n                schema,\n                annotated\n            });\n            result[moduleName] = annotated;\n        }\n    }\n    return result;\n}\nfunction getSchemaWithValuesAndSources(schema) {\n    if (schema.hasOwnProperty('_default')) {\n        return {\n            ...schema,\n            _value: schema._default,\n            _source: 'default'\n        };\n    } else if (isOrdinaryObject(schema)) {\n        return Object.keys(schema).reduce((obj, key)=>{\n            obj[key] = getSchemaWithValuesAndSources(schema[key]);\n            return obj;\n        }, {});\n    } else {\n        // at this point, the schema is bad and an error will have been logged during schema validation\n        return {};\n    }\n}\nfunction createValuesAndSourcesTree(config, source) {\n    if (isOrdinaryObject(config)) {\n        return Object.keys(config).reduce((obj, key)=>{\n            obj[key] = createValuesAndSourcesTree(config[key], source);\n            return obj;\n        }, {});\n    } else {\n        return {\n            _value: config,\n            _source: source\n        };\n    }\n}\nfunction getExtensionSlotConfigs(configState, tempConfigState) {\n    const allConfigs = mergeConfigs(getProvidedConfigs(configState, tempConfigState));\n    const slotConfigPerModule = Object.keys(allConfigs).reduce((obj, key)=>{\n        if (allConfigs[key]?.extensionSlots) {\n            obj[key] = allConfigs[key]?.extensionSlots;\n        }\n        return obj;\n    }, {});\n    validateAllExtensionSlotConfigs(slotConfigPerModule);\n    const slotConfigs = {};\n    const configureBlocks = {};\n    for (const configBySlotName of Object.values(slotConfigPerModule)){\n        for (const [slotName, config] of Object.entries(configBySlotName)){\n            slotConfigs[slotName] = config;\n            if (config.configure) {\n                var _configureBlocks, _slotName;\n                ((_configureBlocks = configureBlocks)[_slotName = slotName] ?? (_configureBlocks[_slotName] = [])).push(config.configure);\n            }\n        }\n    }\n    for (const [slotName, blocks] of Object.entries(configureBlocks)){\n        const configure = blocks.length === 1 ? blocks[0] : mergeConfigs(blocks);\n        if (slotConfigs[slotName].configure !== configure) {\n            slotConfigs[slotName] = {\n                ...slotConfigs[slotName],\n                configure\n            };\n        }\n    }\n    return slotConfigs;\n}\nfunction validateAllExtensionSlotConfigs(slotConfigPerModule) {\n    for (let [moduleName, configBySlotName] of Object.entries(slotConfigPerModule)){\n        for (let [slotName, config] of Object.entries(configBySlotName)){\n            validateExtensionSlotConfig(config, moduleName, slotName);\n        }\n    }\n}\nfunction validateExtensionSlotConfig(config, moduleName, slotName) {\n    const keyPath = `${moduleName}.extensionSlots.${slotName}`;\n    const errorPrefix = `Extension slot config '${keyPath}'`;\n    const invalidKeys = Object.keys(config).filter((k)=>![\n            'add',\n            'remove',\n            'order',\n            'configure'\n        ].includes(k));\n    if (invalidKeys.length) {\n        logError(keyPath, errorPrefix + `' contains invalid keys '${invalidKeys.join(\"', '\")}'`);\n    }\n    if (config.add) {\n        if (!Array.isArray(config.add) || !config.add.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.add' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.remove) {\n        if (!Array.isArray(config.remove) || !config.remove.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.remove' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.order) {\n        if (!Array.isArray(config.order) || !config.order.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.order' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.configure) {\n        if (!isOrdinaryObject(config.configure)) {\n            logError(keyPath, errorPrefix + `.configure' is invalid. Must be an object with extension IDs for keys`);\n        }\n    }\n}\nfunction getProvidedConfigs(configState, tempConfigState) {\n    return [\n        ...configState.providedConfigs.map((c)=>c.config),\n        tempConfigState.config\n    ];\n}\n/**\n * Validates the config schema for a module. Since problems identified here are programming errors\n * that hopefully will be caught during development, this function logs errors to the console directly;\n * it's fine if we spam the user with these errors.\n */ function validateConfigSchema(moduleName, schema, keyPath = '') {\n    const updateMessage = `Please verify that you are running the latest version and, if so, alert the maintainer.`;\n    for (const key of Object.keys(schema).filter((k)=>!k.startsWith('_'))){\n        const thisKeyPath = keyPath + (keyPath && '.') + key;\n        const schemaPart = schema[key];\n        if (thisKeyPath === 'Display conditions') {\n            console.error(`${moduleName} declares a configuration option called \"Display conditions\"; the \"Display conditions\" option is a reserved name. ${updateMessage}`);\n        }\n        if (thisKeyPath === 'Translation overrides') {\n            console.error(`${moduleName} declares a configuration option called \"Translation overrides\"; the \"Translation overrides\" option is a reserved name. ${updateMessage}`);\n        }\n        if (!isOrdinaryObject(schemaPart)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}`);\n            continue;\n        }\n        if (!schemaPart.hasOwnProperty('_default')) {\n            // recurse for nested config keys\n            validateConfigSchema(moduleName, schemaPart, thisKeyPath);\n        }\n        const elements = schemaPart._elements;\n        if (hasObjectSchema(elements)) {\n            validateConfigSchema(moduleName, elements, thisKeyPath + '._elements');\n        }\n        if (schemaPart._validators) {\n            for (let validator of schemaPart._validators){\n                if (typeof validator !== 'function') {\n                    console.error(`${moduleName} has invalid validator for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: validators must be functions that return either ` + `undefined or an error string. Received ${validator}.`);\n                }\n            }\n        }\n        const valueType = schemaPart._type;\n        if (valueType && !Object.values(Type).includes(valueType)) {\n            console.error(`${moduleName} has invalid type for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: the allowed types are ${Object.values(Type).join(', ')}. ` + `Received '${valueType}'`);\n        }\n        if (Object.keys(schemaPart).every((k)=>[\n                '_description',\n                '_validators',\n                '_elements',\n                '_type'\n            ].includes(k)) && !keyPath.includes('._elements')) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: all config elements must have a default. ` + `Received ${JSON.stringify(schemaPart)}`);\n        }\n        if (elements && valueType && ![\n            Type.Array,\n            Type.Object\n        ].includes(valueType)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: the 'elements' key only works with '_type' equal to 'Array' or 'Object'. ` + `Received ${JSON.stringify(valueType)}`);\n        }\n    }\n}\nfunction getConfigForModule(moduleName, configState, tempConfigState) {\n    const schema = configState.schemas[moduleName];\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    validateStructure(schema, inputConfig, moduleName);\n    const config = setDefaults(schema, inputConfig);\n    runAllValidatorsInConfigTree(schema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction getConfigForModuleImplicitSchema(moduleName, configState, tempConfigState) {\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    const config = setDefaults(implicitConfigSchema, inputConfig);\n    runAllValidatorsInConfigTree(implicitConfigSchema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction mergeConfigsFor(moduleName, allConfigs) {\n    const allConfigsForModule = allConfigs.map(({ [moduleName]: c })=>c).filter((c)=>!!c);\n    return mergeConfigs(allConfigsForModule);\n}\n/**\n * Merges a whole list at once, accumulating into one destination.\n */ function mergeConfigs(configs) {\n    return configs.reduce((acc, config)=>mergeWith(acc, config, replaceArrays), {});\n}\n/**\n * Recursively check the provided config tree to make sure that all\n * of the provided properties exist in the schema, and that types are\n * correct. Does not run validators yet, since those will be run on\n * the config with the defaults filled in.\n */ function validateStructure(schema, config, keyPath = '') {\n    // validate each constituent element\n    for (const key of Object.keys(config)){\n        const value = config[key];\n        const thisKeyPath = keyPath + '.' + key;\n        const schemaPart = schema[key];\n        if (!schema.hasOwnProperty(key)) {\n            if (!(key === 'extensionSlots' && keyPath !== '')) {\n                logError(thisKeyPath, `Unknown config key '${thisKeyPath}' provided. Ignoring.`);\n            }\n            continue;\n        }\n        validateBranchStructure(schemaPart, value, thisKeyPath);\n    }\n}\nfunction validateBranchStructure(schemaPart, value, keyPath) {\n    checkType(keyPath, schemaPart._type, value);\n    if (isOrdinaryObject(value)) {\n        if (schemaPart._type === Type.Object) {\n            // validate as freeform object\n            validateFreeformObjectStructure(schemaPart, value, keyPath);\n        } else if (!(schemaPart.hasOwnProperty('_default') || schemaPart.hasOwnProperty('_type'))) {\n            // validate as normal nested config\n            validateStructure(schemaPart, value, keyPath);\n        }\n    } else {\n        if (schemaPart._type === Type.Array) {\n            validateArrayStructure(schemaPart, value, keyPath);\n        }\n    }\n}\nfunction validateFreeformObjectStructure(freeformObjectSchema, config, keyPath) {\n    if (freeformObjectSchema._elements) {\n        for (const key of Object.keys(config)){\n            const value = config[key];\n            validateBranchStructure(freeformObjectSchema._elements, value, `${keyPath}.${key}`);\n        }\n    }\n}\nfunction validateArrayStructure(arraySchema, value, keyPath) {\n    const validatedAsArray = checkType(keyPath, Type.Array, value);\n    if (!validatedAsArray) {\n        return;\n    }\n    // if there is an array element object schema, verify that elements match it\n    if (hasObjectSchema(arraySchema._elements)) {\n        for(let i = 0; i < value.length; i++){\n            validateBranchStructure(arraySchema._elements, value[i], `${keyPath}[${i}]`);\n        }\n    }\n    for(let i = 0; i < value.length; i++){\n        checkType(`${keyPath}[${i}]`, arraySchema._elements?._type, value[i]);\n    }\n}\n/**\n * Run all the validators in the config tree. This should be run\n * on the config object after it has been filled in with all the defaults, since\n * higher-level validators may refer to default values.\n */ function runAllValidatorsInConfigTree(schema, config, keyPath = '') {\n    // If `!schema`, there should have been a structural validation error printed already.\n    if (schema) {\n        if (config !== schema._default) {\n            runValidators(keyPath, schema._validators, config);\n        }\n        if (isOrdinaryObject(config)) {\n            for (const key of Object.keys(config)){\n                const value = config[key];\n                const thisKeyPath = keyPath + '.' + key;\n                const schemaPart = schema[key];\n                if (schema._type === Type.Object && schema._elements) {\n                    runAllValidatorsInConfigTree(schema._elements, value, thisKeyPath);\n                } else {\n                    runAllValidatorsInConfigTree(schemaPart, value, thisKeyPath);\n                }\n            }\n        } else if (Array.isArray(config) && schema._elements) {\n            for(let i = 0; i < config.length; i++){\n                runAllValidatorsInConfigTree(schema._elements, config[i], `${keyPath}[${i}]`);\n            }\n        }\n    }\n}\n/**\n * Run type validation for the value, logging any errors.\n * @returns true if validation passes, false otherwise\n */ function checkType(keyPath, _type, value) {\n    if (_type) {\n        const validator = {\n            Array: isArray,\n            Boolean: isBoolean,\n            ConceptUuid: isUuid,\n            Number: isNumber,\n            Object: isObject,\n            String: isString,\n            UUID: isUuid,\n            PersonAttributeTypeUuid: isUuid,\n            PatientIdentifierTypeUuid: isUuid\n        };\n        return runValidators(keyPath, [\n            validator[_type]\n        ], value);\n    }\n    return true;\n}\n/**\n * Runs validators, logging errors.\n * @returns true if all pass, false otherwise.\n */ function runValidators(keyPath, validators, value) {\n    let returnValue = true;\n    if (validators) {\n        try {\n            for (let validator of validators){\n                const validatorResult = validator(value);\n                if (typeof validatorResult === 'string') {\n                    const message = typeof value === 'object' ? `Invalid configuration for ${keyPath}: ${validatorResult}` : `Invalid configuration value ${value} for ${keyPath}: ${validatorResult}`;\n                    logError(keyPath, message);\n                    returnValue = false;\n                }\n            }\n        } catch (e) {\n            console.error(`Skipping invalid validator at \"${keyPath}\". Encountered error\\n\\t${e}`);\n        }\n    }\n    return returnValue;\n}\n// Recursively fill in the config with values from the schema.\nconst setDefaults = (schema, inputConfig)=>{\n    const config = structuredClone(inputConfig);\n    if (!schema) {\n        return config;\n    }\n    for (const key of Object.keys(schema)){\n        const configPart = config[key];\n        const schemaPart = schema[key];\n        // The `schemaPart &&` clause of this `if` statement will only fail\n        // if the schema is very invalid. It is there to prevent the app from\n        // crashing completely, though it will produce unexpected behavior.\n        // If this happens, there should be legible errors in the console from\n        // the schema validator.\n        if (schemaPart && (schemaPart.hasOwnProperty('_type') || schemaPart.hasOwnProperty('_default'))) {\n            // We assume that schemaPart defines a config value, since it has\n            // a property `_type` or `_default`.\n            if (!config.hasOwnProperty(key)) {\n                config[key] = schemaPart['_default'];\n            }\n            // We also check if it is an object or array with object elements, in which case we recurse\n            const elements = schemaPart._elements;\n            if (configPart && hasObjectSchema(elements)) {\n                if (schemaPart._type === Type.Array && Array.isArray(configPart)) {\n                    const configWithDefaults = configPart.map((conf)=>setDefaults(elements, conf));\n                    config[key] = configWithDefaults;\n                } else if (schemaPart._type === Type.Object) {\n                    for (let objectKey of Object.keys(configPart)){\n                        configPart[objectKey] = setDefaults(elements, configPart[objectKey]);\n                    }\n                }\n            }\n        } else if (isOrdinaryObject(schemaPart)) {\n            // Since schemaPart has no property \"_type\", if it's an ordinary object\n            // (unlike, importantly, the validators array), we assume it is a parent config property.\n            // We recurse to config[key] and schema[key]. Default config[key] to {}.\n            const selectedConfigPart = configPart ?? {};\n            // There will have been a validation error already if configPart is not a plain object.\n            if (isOrdinaryObject(selectedConfigPart)) {\n                config[key] = setDefaults(schemaPart, selectedConfigPart);\n            }\n        }\n    }\n    return config;\n};\nfunction hasObjectSchema(elementsSchema) {\n    return !!elementsSchema && Object.keys(elementsSchema).filter((e)=>![\n            '_default',\n            '_validators'\n        ].includes(e)).length > 0;\n}\nfunction isOrdinaryObject(value) {\n    return typeof value === 'object' && !Array.isArray(value) && value !== null;\n}\n/** Keep track of which validation errors we have displayed. Each one should only be displayed once. */ let displayedValidationMessages = new Set();\nfunction logError(keyPath, message) {\n    const key = `${keyPath}:::${message}`;\n    // technically, this should not be possible, but because of how things wind-up transpiled, this isn't impossible\n    if (!displayedValidationMessages) {\n        displayedValidationMessages = new Set();\n    }\n    if (!displayedValidationMessages.has(key)) {\n        console.error(message);\n        displayedValidationMessages.add(key);\n    }\n}\n/**\n * Normally, configuration errors are only displayed once. This function clears the list of\n * displayed errors, so that they will be displayed again.\n *\n * @internal\n */ export function clearConfigErrors(keyPath) {\n    if (keyPath) {\n        displayedValidationMessages.forEach((key)=>{\n            if (key.startsWith(keyPath)) {\n                displayedValidationMessages.delete(key);\n            }\n        });\n    } else {\n        displayedValidationMessages.clear();\n    }\n}\n/**\n * Cleans up all config store subscriptions and re-establishes them. This is primarily\n * useful for testing, where subscriptions set up at module load time need to be cleared\n * between tests to prevent infinite update loops. After clearing, subscriptions are\n * re-established so the config system continues to work normally.\n *\n * @internal\n */ export function resetConfigSystem() {\n    configSubscriptions.forEach((unsubscribe)=>unsubscribe());\n    configSubscriptions.length = 0;\n    // Cached configs are keyed on input identity, so a test that reuses the same schema or config\n    // objects across cases would otherwise be served the previous case's result.\n    moduleConfigCache.clear();\n    extensionConfigCache.clear();\n    schemaValuesAndSourcesCache.clear();\n    implementerToolsModuleCache.clear();\n    setupConfigSubscriptions();\n}\n/**\n * Copied over from esm-extensions. It rightly belongs to that module, but esm-config\n * cannot depend on esm-extensions.\n */ function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\n/**\n * The translation overrides schema is used in the implicit schema given to every module;\n * plus any additional translation namespaces (at time of writing, this is just 'core').\n */ const translationOverridesSchema = {\n    'Translation overrides': {\n        _description: 'Per-language overrides for frontend translations should be keyed by language code and each language dictionary contains the translation key and the display value',\n        _type: Type.Object,\n        _default: {},\n        _validators: [\n            validator((o)=>Object.keys(o).every((k)=>/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k)), (o)=>{\n                const badKeys = Object.keys(o).filter((k)=>!/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k));\n                return `The 'Translation overrides' object should have language codes for keys. Language codes must be in the form of a two-to-three letter language code optionally followed by a hyphen and a two-to-three letter country code. The following keys do not conform: ${badKeys.join(', ')}.`;\n            })\n        ]\n    }\n};\n/**\n * The implicitConfigSchema is implicitly included in every configuration schema\n */ const implicitConfigSchema = {\n    'Display conditions': {\n        privileges: {\n            _description: 'The privilege(s) the user must have to use this extension',\n            _type: Type.Array,\n            _default: []\n        },\n        expression: {\n            _description: 'The expression that determines whether the extension is displayed',\n            _type: Type.String,\n            _default: undefined\n        }\n    },\n    ...translationOverridesSchema\n};\n"],"names":["cloneDeep","isEqual","mergeWith","omit","lodashOmit","Type","isArray","isBoolean","isUuid","isNumber","isObject","isString","validator","configExtensionStore","configInternalStore","getConfigStore","getExtensionConfig","getExtensionSlotsConfigStore","getExtensionsConfigStore","clearConfigDerivationError","implementerToolsConfigStore","invalidateImplementerToolsConfig","recordConfigDerivationError","setImplementerToolsConfigRecomputer","temporaryConfigStore","replaceArrays","_objValue","srcValue","Array","mergeDeepReplace","left","right","configSubscriptions","recomputeAllConfigs","configState","tempConfigState","extensionState","computeModuleConfig","slotConfigs","getExtensionSlotConfigs","computeExtensionSlotConfigs","computeExtensionConfigs","setupConfigSubscriptions","computeImplementerToolsConfig","recomputeAllConfigsSafely","e","console","moduleConfigCache","Map","state","tempState","moduleName","Object","moduleStore","schema","moduleLoaded","Boolean","cached","newState","config","getConfigForModule","getConfigForModuleImplicitSchema","oldState","slotStore","oldSlots","slots","changed","slotName","previous","getImplementerToolsConfig","extensionsConfigStore","oldConfigs","configs","entryCount","extension","computeExtensionConfig","entry","previousSlot","extensionId","total","slot","defineConfigSchema","validateConfigSchema","enhancedSchema","implicitConfigSchema","registerModuleWithConfigSystem","registerModuleLoad","registerTranslationNamespace","namespace","translationOverridesSchema","defineExtensionConfigSchema","extensionName","provide","sourceName","whenStoreReady","store","ready","select","Promise","resolve","unsubscribe","resolved","update","getConfig","getTranslationOverrides","promises","processConfig","providedConfig","keyPathContext","validateStructure","setDefaults","runAllValidatorsInConfigTree","extensionConfigCache","slotModuleName","extensionModuleName","slotConfig","getExtensionNameFromId","extensionConfigSchema","cacheKey","JSON","nameOfSchemaSource","providedConfigs","getProvidedConfigs","sharedOverride","slotModuleConfig","mergeConfigsFor","configOverride","extensionConfig","combinedConfig","mergeConfigs","implementerToolsModuleCache","annotatedSchemas","getAllSchemasWithValuesAndSources","configsAndSources","c","moduleNames","Set","result","annotatedSchema","configSlices","sources","source","slice","i","merged","undefined","createValuesAndSourcesTree","schemaValuesAndSourcesCache","schemas","annotated","getSchemaWithValuesAndSources","isOrdinaryObject","obj","key","allConfigs","slotConfigPerModule","validateAllExtensionSlotConfigs","configureBlocks","configBySlotName","_configureBlocks","_slotName","blocks","configure","validateExtensionSlotConfig","keyPath","errorPrefix","invalidKeys","k","logError","n","updateMessage","thisKeyPath","schemaPart","elements","hasObjectSchema","valueType","inputConfig","allConfigsForModule","acc","value","validateBranchStructure","checkType","validateFreeformObjectStructure","validateArrayStructure","freeformObjectSchema","arraySchema","validatedAsArray","runValidators","_type","validators","returnValue","validatorResult","message","structuredClone","configPart","configWithDefaults","conf","objectKey","selectedConfigPart","elementsSchema","displayedValidationMessages","clearConfigErrors","resetConfigSystem","o","badKeys"],"mappings":"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"}\n//# sourceURL=webpack-internal:///../../framework/esm-config/dist/module-config/module-config.js\n\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  clearConfigErrors: () => (clearConfigErrors),\n  defineConfigSchema: () => (defineConfigSchema),\n  defineExtensionConfigSchema: () => (defineExtensionConfigSchema),\n  getConfig: () => (getConfig),\n  getTranslationOverrides: () => (getTranslationOverrides),\n  processConfig: () => (processConfig),\n  provide: () => (provide),\n  registerModuleLoad: () => (registerModuleLoad),\n  registerModuleWithConfigSystem: () => (registerModuleWithConfigSystem),\n  registerTranslationNamespace: () => (registerTranslationNamespace),\n  resetConfigSystem: () => (resetConfigSystem)\n});\n/* import */ var lodash_es__rspack_import_4 = __webpack_require__(\"../../../node_modules/lodash-es/mergeWith.js\");\n/* import */ var lodash_es__rspack_import_5 = __webpack_require__(\"../../../node_modules/lodash-es/isEqual.js\");\n/* import */ var lodash_es__rspack_import_6 = __webpack_require__(\"../../../node_modules/lodash-es/omit.js\");\n/* import */ var lodash_es__rspack_import_7 = __webpack_require__(\"../../../node_modules/lodash-es/cloneDeep.js\");\n/* import */ var _types_js__rspack_import_0 = __webpack_require__(\"../../framework/esm-config/dist/types.js\");\n/* import */ var _validators_type_validators_js__rspack_import_1 = __webpack_require__(\"../../framework/esm-config/dist/validators/type-validators.js\");\n/* import */ var _validators_validator_js__rspack_import_2 = __webpack_require__(\"../../framework/esm-config/dist/validators/validator.js\");\n/* import */ var _state_js__rspack_import_3 = __webpack_require__(\"../../framework/esm-config/dist/module-config/state.js\");\n/** @module @category Config */ \n\n\n\n\n/**\n * Deep merge two objects, with right-side values taking precedence.\n * Arrays are replaced entirely (not merged by index), matching the\n * behavior of ramda's mergeDeepRight.\n */ function replaceArrays(_objValue, srcValue) {\n    if (Array.isArray(srcValue)) {\n        return srcValue;\n    }\n}\nfunction mergeDeepReplace(left, right) {\n    return (0,lodash_es__rspack_import_4[\"default\"])({}, left, right, replaceArrays);\n}\n/**\n * Store setup\n *\n *\n * Set up stores and subscriptions so that inputs get processed appropriately.\n *\n * There are *input* stores and *output* stores. The *input* stores\n * are configInternalStore, temporaryConfigStore, and configExtensionStore. The\n * output stores are set in the `compute...` functions. They are the module\n * config stores, the extension slot config stores (by module), the extension\n * config stores, and the implementer tools config store.\n *\n * This code sets up the subscriptions so that when an input store changes,\n * the correct set of output stores are updated.\n *\n * All `compute...` functions except `computeExtensionConfigs` are pure\n * (or are supposed to be), other than the fact that they all `setState`\n * store values at the end. `computeExtensionConfigs` calls `getGlobalStore`,\n * which creates stores.\n */ // Store unsubscribe functions to allow cleanup (e.g., in tests or hot module reloading)\nconst configSubscriptions = [];\n/**\n * Recomputes all configuration derived stores based on current state of input stores.\n * Called whenever any input store (configInternalStore, temporaryConfigStore, configExtensionStore) changes.\n */ function recomputeAllConfigs() {\n    const configState = _state_js__rspack_import_3.configInternalStore.getState();\n    const tempConfigState = _state_js__rspack_import_3.temporaryConfigStore.getState();\n    const extensionState = _state_js__rspack_import_3.configExtensionStore.getState();\n    // Mounting an extension changes only `configExtensionStore`, which only the extension configs\n    // depend on, so the rest of the last derivation is reused.\n    const configInputsUnchanged = lastDerivation?.configState === configState && lastDerivation.tempConfigState === tempConfigState;\n    if (configInputsUnchanged) {\n        computeExtensionConfigs(configState, extensionState, tempConfigState, lastDerivation.slotConfigs, true);\n        return;\n    }\n    computeModuleConfig(configState, tempConfigState);\n    const slotConfigs = getExtensionSlotConfigs(configState, tempConfigState);\n    computeExtensionSlotConfigs(slotConfigs);\n    computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs, false);\n    // Recorded only after the outputs above are written, so a failure forces a full derivation next time.\n    lastDerivation = {\n        configState,\n        tempConfigState,\n        slotConfigs\n    };\n    // Last, because a failure here must not skip the outputs above. Only kept current while the\n    // implementer tools are watching it; otherwise derived on read.\n    (0,_state_js__rspack_import_3.invalidateImplementerToolsConfig)();\n}\n/** The inputs the outputs were last fully derived from, compared by identity. */ let lastDerivation = null;\n/**\n * The mounted extension each extension config entry was derived for. An extension ID can be\n * mounted under a different module while its slot and ID stay the same, so an entry is only\n * current if its modules match too.\n */ let entryOrigins = new WeakMap();\nfunction setupConfigSubscriptions() {\n    // Registered here rather than at module load so that `resetConfigSystem` restores it.\n    (0,_state_js__rspack_import_3.setImplementerToolsConfigRecomputer)(()=>computeImplementerToolsConfig(_state_js__rspack_import_3.configInternalStore.getState(), _state_js__rspack_import_3.temporaryConfigStore.getState()));\n    // Initial computation\n    recomputeAllConfigs();\n    // Subscribe to all input stores with a single handler\n    // This ensures we only recompute once even if multiple stores change simultaneously\n    configSubscriptions.push(_state_js__rspack_import_3.configInternalStore.subscribe(recomputeAllConfigsSafely), _state_js__rspack_import_3.temporaryConfigStore.subscribe(recomputeAllConfigsSafely), _state_js__rspack_import_3.configExtensionStore.subscribe(recomputeAllConfigsSafely));\n}\n/** Ensure that we do not throw during a store subscription */ function recomputeAllConfigsSafely() {\n    (0,_state_js__rspack_import_3.clearConfigDerivationError)();\n    try {\n        recomputeAllConfigs();\n    } catch (e) {\n        (0,_state_js__rspack_import_3.recordConfigDerivationError)(e);\n        console.error('Failed to recompute the configuration', e);\n    }\n}\n// Set up subscriptions at module load time\nsetupConfigSubscriptions();\nconst moduleConfigCache = new Map();\nfunction computeModuleConfig(state, tempState) {\n    for (let moduleName of Object.keys(state.schemas)){\n        // At this point the schema could be either just the implicit schema or the actually\n        // defined schema. We run with just the implicit schema because we want to populate\n        // the config store with the translation overrides as soon as possible. In fact, the\n        // translation system will throw for Suspense until the translation overrides are\n        // available, which as of this writing blocks the schema definition from occurring\n        // for modules loaded based on their extensions.\n        const moduleStore = (0,_state_js__rspack_import_3.getConfigStore)(moduleName);\n        const schema = state.schemas[moduleName];\n        const moduleLoaded = Boolean(state.moduleLoaded[moduleName]);\n        const cached = moduleConfigCache.get(moduleName);\n        let newState;\n        if (cached && cached.schema === schema && cached.moduleLoaded === moduleLoaded && cached.providedConfigs === state.providedConfigs && cached.temporaryConfig === tempState.config) {\n            newState = cached.state;\n        } else {\n            const config = moduleLoaded ? getConfigForModule(moduleName, state, tempState) : getConfigForModuleImplicitSchema(moduleName, state, tempState);\n            newState = {\n                translationOverridesLoaded: true,\n                loaded: moduleLoaded,\n                config\n            };\n            moduleConfigCache.set(moduleName, {\n                schema,\n                moduleLoaded,\n                providedConfigs: state.providedConfigs,\n                temporaryConfig: tempState.config,\n                state: newState\n            });\n        }\n        // Writing unconditionally would hand every `useConfig` consumer in the application a new\n        // object — and a re-render — whenever any module or extension anywhere is loaded.\n        const oldState = moduleStore.getState();\n        if (oldState.loaded !== newState.loaded || oldState.translationOverridesLoaded !== newState.translationOverridesLoaded || !(0,lodash_es__rspack_import_5[\"default\"])(oldState.config, newState.config)) {\n            moduleStore.setState(newState);\n        }\n    }\n}\nfunction computeExtensionSlotConfigs(slotConfigs) {\n    const slotStore = (0,_state_js__rspack_import_3.getExtensionSlotsConfigStore)();\n    const oldSlots = slotStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    for (const [slotName, config] of Object.entries(slotConfigs)){\n        const previous = oldSlots[slotName];\n        // Entries keep their identity when the configuration behind them hasn't changed, so that\n        // changing one slot's configuration doesn't invalidate every other configured slot.\n        if (previous?.loaded && (0,lodash_es__rspack_import_5[\"default\"])(previous.config, config)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                loaded: true,\n                config\n            };\n            changed = true;\n        }\n    }\n    // Built from scratch rather than merged over the previous state: a slot whose configuration\n    // has been removed — clearing the temporary config, say — has to lose its entry, or the old\n    // configuration stays in force until the page is reloaded.\n    if (changed || Object.keys(oldSlots).length !== Object.keys(slots).length) {\n        slotStore.setState({\n            slots\n        });\n    }\n}\nfunction computeImplementerToolsConfig(state, tempConfigState) {\n    const oldState = _state_js__rspack_import_3.implementerToolsConfigStore.getState();\n    const config = getImplementerToolsConfig(state, tempConfigState);\n    const newState = {\n        config\n    };\n    // Use deep equality on the actual config content, not the wrapper object\n    if (!(0,lodash_es__rspack_import_5[\"default\"])(oldState.config, newState.config)) {\n        _state_js__rspack_import_3.implementerToolsConfigStore.setState(newState);\n    }\n}\nfunction computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs, configInputsUnchanged) {\n    const extensionsConfigStore = (0,_state_js__rspack_import_3.getExtensionsConfigStore)();\n    const oldConfigs = extensionsConfigStore.getState().configs;\n    const configs = {};\n    let changed = false;\n    let entryCount = 0;\n    // We assume that the module schema has already been defined, since the extension\n    // it contains is mounted.\n    for (let extension of extensionState.mountedExtensions){\n        const previous = oldConfigs[extension.slotName]?.[extension.extensionId];\n        let entry;\n        const origin = previous && entryOrigins.get(previous);\n        if (configInputsUnchanged && previous?.loaded && origin?.slotModuleName === extension.slotModuleName && origin.extensionModuleName === extension.extensionModuleName) {\n            // Derived from these same inputs by the previous run, so it is still current.\n            entry = previous;\n        } else {\n            const config = computeExtensionConfig(extension.slotModuleName, extension.extensionModuleName, extension.slotName, extension.extensionId, configState, tempConfigState, slotConfigs[extension.slotName]);\n            // Entries keep their identity when the configuration behind them hasn't changed, so that\n            // mounting one extension doesn't hand every other mounted extension a new config object.\n            entry = previous?.loaded && (0,lodash_es__rspack_import_5[\"default\"])(previous.config, config) ? previous : {\n                config,\n                loaded: true\n            };\n        }\n        entryOrigins.set(entry, extension);\n        if (entry !== previous) {\n            changed = true;\n        }\n        if (!configs[extension.slotName]) {\n            configs[extension.slotName] = {};\n        }\n        configs[extension.slotName][extension.extensionId] = entry;\n        entryCount++;\n    }\n    // Slots keep their identity too when none of their entries changed. Subscribers compare these\n    // per-slot objects to work out which slots to re-derive, so handing out a fresh one for every\n    // slot on every write would mark every slot with a mounted extension dirty.\n    for (const [slotName, slotConfigs] of Object.entries(configs)){\n        const previousSlot = oldConfigs[slotName];\n        if (previousSlot && Object.keys(previousSlot).length === Object.keys(slotConfigs).length && Object.entries(slotConfigs).every(([extensionId, entry])=>previousSlot[extensionId] === entry)) {\n            configs[slotName] = previousSlot;\n        }\n    }\n    if (!changed) {\n        // Nothing was added or altered, but an extension may have unmounted, which only shows up as a\n        // missing entry.\n        changed = Object.keys(oldConfigs).length !== Object.keys(configs).length || Object.values(oldConfigs).reduce((total, slot)=>total + Object.keys(slot).length, 0) !== entryCount;\n    }\n    if (changed) {\n        extensionsConfigStore.setState({\n            configs\n        });\n    }\n}\n/*\n * API\n *\n */ /**\n * This defines a configuration schema for a module. The schema tells the\n * configuration system how the module can be configured. It specifies\n * what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param moduleName Name of the module the schema is being defined for. Generally\n *   should be the one in which the `defineConfigSchema` call takes place.\n * @param schema The config schema for the module\n */ function defineConfigSchema(moduleName, schema) {\n    validateConfigSchema(moduleName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: enhancedSchema\n            },\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module exists. This allows config to be\n * processed, while still allowing the extension system to know whether the module has\n * actually had its front bundle executed yet.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ function registerModuleWithConfigSystem(moduleName) {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: implicitConfigSchema\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module has been loaded.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ function registerModuleLoad(moduleName) {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This allows the config system to support translation overrides for namespaces that\n * do not correspond to modules.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param namespace\n */ function registerTranslationNamespace(namespace) {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [namespace]: translationOverridesSchema\n            }\n        }));\n}\n/**\n * This defines a configuration schema for an extension. When a schema is defined\n * for an extension, that extension will receive the configuration corresponding\n * to that schema, rather than the configuration corresponding to the module\n * in which it is defined.\n *\n * The schema tells the configuration system how the module can be configured.\n * It specifies what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param extensionName Name of the extension the schema is being defined for.\n *   Should match the `name` of one of the `extensions` entries defined in\n *   the app's `routes.json` file.\n * @param schema The config schema for the extension\n */ function defineExtensionConfigSchema(extensionName, schema) {\n    validateConfigSchema(extensionName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    const state = _state_js__rspack_import_3.configInternalStore.getState();\n    if (state.schemas[extensionName]) {\n        console.error(`Config schema for extension ${extensionName} already exists. If there are multiple extensions with this same name, one will probably crash.`);\n    }\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [extensionName]: enhancedSchema\n            }\n        }));\n}\n/**\n * Provides configuration values programmatically. This is an alternative to\n * providing configuration through the config-file. Configuration provided this\n * way will be merged with configuration from other sources.\n *\n * @param config A configuration object to merge into the existing configuration.\n * @param sourceName An optional name to identify the source of this configuration,\n *   used for debugging purposes. Defaults to 'provided'.\n */ function provide(config, sourceName = 'provided') {\n    _state_js__rspack_import_3.configInternalStore.setState((state)=>({\n            ...state,\n            providedConfigs: [\n                ...state.providedConfigs,\n                {\n                    source: sourceName,\n                    config\n                }\n            ]\n        }));\n}\n/**\n * Resolves with `select(state)` as soon as the store's state satisfies `ready`, leaving no\n * subscription behind: nothing subscribes at all when the store is already ready. That matters\n * because `getConfig` runs on every HTTP request, and a subscription that outlives its promise\n * both retains its closure forever and slows down every later write to that store.\n */ function whenStoreReady(store, ready, select) {\n    return new Promise((resolve)=>{\n        let unsubscribe;\n        let resolved = false;\n        function update(state) {\n            if (!resolved && ready(state)) {\n                resolved = true;\n                resolve(select(state));\n                unsubscribe?.();\n            }\n        }\n        update(store.getState());\n        if (!resolved) {\n            unsubscribe = store.subscribe(update);\n        }\n    });\n}\n/**\n * A promise-based way to access the config as soon as it is fully loaded.\n * If it is already loaded, resolves the config in its present state.\n *\n * This is a useful function if you need to get the config in the course\n * of the execution of a function.\n *\n * @param moduleName The name of the module for which to look up the config\n */ function getConfig(moduleName) {\n    return whenStoreReady((0,_state_js__rspack_import_3.getConfigStore)(moduleName), (state)=>Boolean(state.loaded && state.config), (state)=>(0,lodash_es__rspack_import_6[\"default\"])(state.config, [\n            'Display conditions',\n            'Translation overrides'\n        ]));\n}\n/**\n * Retrieves translation overrides for an extension, optionally scoped to a specific\n * extension slot. When called with only a module name, retrieves module-level overrides.\n * Translation overrides allow customizing translated strings without modifying the\n * original translation files.\n *\n * @param moduleName The name of the module providing the translation context.\n * @param slotName Optional extension slot name to include slot-specific overrides.\n * @param extensionId Optional extension ID to include extension-specific overrides.\n * @returns A Promise resolving to an array of translation override objects.\n *\n * @internal\n */ function getTranslationOverrides(moduleName, slotName, extensionId) {\n    const promises = [\n        whenStoreReady((0,_state_js__rspack_import_3.getConfigStore)(moduleName), (state)=>Boolean(state.translationOverridesLoaded && state.config), (state)=>state.config['Translation overrides'] ?? {})\n    ];\n    if (slotName && extensionId) {\n        promises.push(whenStoreReady((0,_state_js__rspack_import_3.getExtensionConfig)(slotName, extensionId), (state)=>Boolean(state.loaded && state.config), (state)=>state.config['Translation overrides'] ?? {}));\n    }\n    return Promise.all(promises);\n}\n/**\n * Validate and interpolate defaults for `providedConfig` according to `schema`\n *\n * @param schema  a configuration schema\n * @param providedConfig  an object of config values (without the top-level module name)\n * @param keyPathContext  a dot-separated string which helps the user figure out where\n *     the provided config came from\n * @returns The validated and processed configuration object with defaults applied.\n * @internal\n */ function processConfig(schema, providedConfig, keyPathContext) {\n    validateStructure(schema, providedConfig, keyPathContext);\n    const config = setDefaults(schema, providedConfig);\n    runAllValidatorsInConfigTree(schema, config, keyPathContext);\n    return config;\n}\nconst extensionConfigCache = new Map();\n/**\n * Returns the configuration for an extension. This configuration is specific\n * to the slot in which it is mounted, and its ID within that slot.\n *\n * The schema for that configuration is the extension schema. If no extension\n * schema has been provided, the schema used is the schema of the module in\n * which the extension is defined.\n *\n * @param slotModuleName The name of the module which defines the extension slot\n * @param extensionModuleName The name of the module which defines the extension (and therefore the config schema)\n * @param slotName The name of the extension slot where the extension is mounted\n * @param extensionId The ID of the extension in its slot\n * @param slotConfig The slot's configuration, gathered from every module that configures it\n */ function computeExtensionConfig(slotModuleName, extensionModuleName, slotName, extensionId, configState, tempConfigState, slotConfig) {\n    const extensionName = getExtensionNameFromId(extensionId);\n    const extensionConfigSchema = configState.schemas[extensionName];\n    // JSON string of these elements should be unique-per-extension\n    const cacheKey = JSON.stringify([\n        slotName,\n        extensionId,\n        slotModuleName,\n        extensionModuleName\n    ]);\n    const cached = extensionConfigCache.get(cacheKey);\n    if (cached && cached.extensionSchema === extensionConfigSchema && cached.extensionModuleSchema === configState.schemas[extensionModuleName] && cached.providedConfigs === configState.providedConfigs && cached.temporaryConfig === tempConfigState.config) {\n        return cached.config;\n    }\n    const nameOfSchemaSource = extensionConfigSchema ? extensionName : extensionModuleName;\n    const providedConfigs = getProvidedConfigs(configState, tempConfigState);\n    const sharedOverride = slotConfig?.configure?.[extensionId] ?? {};\n    const slotModuleConfig = mergeConfigsFor(slotModuleName, providedConfigs);\n    const configOverride = slotModuleConfig?.extensionSlots?.[slotName]?.configure?.[extensionId] ?? {};\n    const extensionConfig = mergeConfigsFor(nameOfSchemaSource, providedConfigs);\n    const combinedConfig = mergeConfigs([\n        extensionConfig,\n        sharedOverride,\n        configOverride\n    ]);\n    const schema = extensionConfigSchema ?? configState.schemas[extensionModuleName];\n    validateStructure(schema, combinedConfig, nameOfSchemaSource);\n    const config = setDefaults(schema, combinedConfig);\n    runAllValidatorsInConfigTree(schema, config, nameOfSchemaSource);\n    delete config.extensionSlots;\n    extensionConfigCache.set(cacheKey, {\n        extensionSchema: extensionConfigSchema,\n        extensionModuleSchema: configState.schemas[extensionModuleName],\n        providedConfigs: configState.providedConfigs,\n        temporaryConfig: tempConfigState.config,\n        config\n    });\n    return config;\n}\nconst implementerToolsModuleCache = new Map();\nfunction getImplementerToolsConfig(configState, tempConfigState) {\n    const annotatedSchemas = getAllSchemasWithValuesAndSources(configState.schemas);\n    const configsAndSources = [\n        ...configState.providedConfigs.map((c)=>[\n                c.config,\n                c.source\n            ]),\n        [\n            tempConfigState.config,\n            'temporary config'\n        ]\n    ];\n    // A module can be configured without having declared a schema, so the module list is the union\n    // of both rather than just the schemas.\n    const moduleNames = new Set(Object.keys(annotatedSchemas));\n    for (const [config] of configsAndSources){\n        for (const moduleName of Object.keys(config)){\n            moduleNames.add(moduleName);\n        }\n    }\n    const result = {};\n    for (const moduleName of moduleNames){\n        const annotatedSchema = annotatedSchemas[moduleName];\n        const configSlices = configsAndSources.map(([config])=>config[moduleName]);\n        const sources = configsAndSources.map(([, source])=>source);\n        const cached = implementerToolsModuleCache.get(moduleName);\n        if (cached && cached.annotatedSchema === annotatedSchema && cached.configSlices.length === configSlices.length && cached.configSlices.every((slice, i)=>slice === configSlices[i]) && cached.sources.every((source, i)=>source === sources[i])) {\n            result[moduleName] = cached.result;\n            continue;\n        }\n        let merged = annotatedSchema ?? {};\n        configsAndSources.forEach(([, source], i)=>{\n            const slice = configSlices[i];\n            if (slice !== undefined) {\n                merged = mergeDeepReplace(merged, createValuesAndSourcesTree(slice, source));\n            }\n        });\n        implementerToolsModuleCache.set(moduleName, {\n            annotatedSchema,\n            configSlices,\n            sources,\n            result: merged\n        });\n        result[moduleName] = merged;\n    }\n    return result;\n}\n/**\n * Caching per module is what stops the walk being quadratic: defining one module's schema\n * recomputes every module.\n *\n * A module with no configuration of its own is published straight from this cache, so nothing may\n * mutate a tree it reads out of the implementer tools config — it is the cache entry.\n */ const schemaValuesAndSourcesCache = new Map();\nfunction getAllSchemasWithValuesAndSources(schemas) {\n    const result = {};\n    for (const [moduleName, schema] of Object.entries(schemas)){\n        const cached = schemaValuesAndSourcesCache.get(moduleName);\n        if (cached && cached.schema === schema) {\n            result[moduleName] = cached.annotated;\n        } else {\n            const annotated = getSchemaWithValuesAndSources((0,lodash_es__rspack_import_7[\"default\"])(schema));\n            schemaValuesAndSourcesCache.set(moduleName, {\n                schema,\n                annotated\n            });\n            result[moduleName] = annotated;\n        }\n    }\n    return result;\n}\nfunction getSchemaWithValuesAndSources(schema) {\n    if (schema.hasOwnProperty('_default')) {\n        return {\n            ...schema,\n            _value: schema._default,\n            _source: 'default'\n        };\n    } else if (isOrdinaryObject(schema)) {\n        return Object.keys(schema).reduce((obj, key)=>{\n            obj[key] = getSchemaWithValuesAndSources(schema[key]);\n            return obj;\n        }, {});\n    } else {\n        // at this point, the schema is bad and an error will have been logged during schema validation\n        return {};\n    }\n}\nfunction createValuesAndSourcesTree(config, source) {\n    if (isOrdinaryObject(config)) {\n        return Object.keys(config).reduce((obj, key)=>{\n            obj[key] = createValuesAndSourcesTree(config[key], source);\n            return obj;\n        }, {});\n    } else {\n        return {\n            _value: config,\n            _source: source\n        };\n    }\n}\nfunction getExtensionSlotConfigs(configState, tempConfigState) {\n    const allConfigs = mergeConfigs(getProvidedConfigs(configState, tempConfigState));\n    const slotConfigPerModule = Object.keys(allConfigs).reduce((obj, key)=>{\n        if (allConfigs[key]?.extensionSlots) {\n            obj[key] = allConfigs[key]?.extensionSlots;\n        }\n        return obj;\n    }, {});\n    validateAllExtensionSlotConfigs(slotConfigPerModule);\n    const slotConfigs = {};\n    const configureBlocks = {};\n    for (const configBySlotName of Object.values(slotConfigPerModule)){\n        for (const [slotName, config] of Object.entries(configBySlotName)){\n            slotConfigs[slotName] = config;\n            if (config.configure) {\n                var _configureBlocks, _slotName;\n                ((_configureBlocks = configureBlocks)[_slotName = slotName] ?? (_configureBlocks[_slotName] = [])).push(config.configure);\n            }\n        }\n    }\n    for (const [slotName, blocks] of Object.entries(configureBlocks)){\n        const configure = blocks.length === 1 ? blocks[0] : mergeConfigs(blocks);\n        if (slotConfigs[slotName].configure !== configure) {\n            slotConfigs[slotName] = {\n                ...slotConfigs[slotName],\n                configure\n            };\n        }\n    }\n    return slotConfigs;\n}\nfunction validateAllExtensionSlotConfigs(slotConfigPerModule) {\n    for (let [moduleName, configBySlotName] of Object.entries(slotConfigPerModule)){\n        for (let [slotName, config] of Object.entries(configBySlotName)){\n            validateExtensionSlotConfig(config, moduleName, slotName);\n        }\n    }\n}\nfunction validateExtensionSlotConfig(config, moduleName, slotName) {\n    const keyPath = `${moduleName}.extensionSlots.${slotName}`;\n    const errorPrefix = `Extension slot config '${keyPath}'`;\n    const invalidKeys = Object.keys(config).filter((k)=>![\n            'add',\n            'remove',\n            'order',\n            'configure'\n        ].includes(k));\n    if (invalidKeys.length) {\n        logError(keyPath, errorPrefix + `' contains invalid keys '${invalidKeys.join(\"', '\")}'`);\n    }\n    if (config.add) {\n        if (!Array.isArray(config.add) || !config.add.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.add' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.remove) {\n        if (!Array.isArray(config.remove) || !config.remove.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.remove' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.order) {\n        if (!Array.isArray(config.order) || !config.order.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.order' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.configure) {\n        if (!isOrdinaryObject(config.configure)) {\n            logError(keyPath, errorPrefix + `.configure' is invalid. Must be an object with extension IDs for keys`);\n        }\n    }\n}\nfunction getProvidedConfigs(configState, tempConfigState) {\n    return [\n        ...configState.providedConfigs.map((c)=>c.config),\n        tempConfigState.config\n    ];\n}\n/**\n * Validates the config schema for a module. Since problems identified here are programming errors\n * that hopefully will be caught during development, this function logs errors to the console directly;\n * it's fine if we spam the user with these errors.\n */ function validateConfigSchema(moduleName, schema, keyPath = '') {\n    const updateMessage = `Please verify that you are running the latest version and, if so, alert the maintainer.`;\n    for (const key of Object.keys(schema).filter((k)=>!k.startsWith('_'))){\n        const thisKeyPath = keyPath + (keyPath && '.') + key;\n        const schemaPart = schema[key];\n        if (thisKeyPath === 'Display conditions') {\n            console.error(`${moduleName} declares a configuration option called \"Display conditions\"; the \"Display conditions\" option is a reserved name. ${updateMessage}`);\n        }\n        if (thisKeyPath === 'Translation overrides') {\n            console.error(`${moduleName} declares a configuration option called \"Translation overrides\"; the \"Translation overrides\" option is a reserved name. ${updateMessage}`);\n        }\n        if (!isOrdinaryObject(schemaPart)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}`);\n            continue;\n        }\n        if (!schemaPart.hasOwnProperty('_default')) {\n            // recurse for nested config keys\n            validateConfigSchema(moduleName, schemaPart, thisKeyPath);\n        }\n        const elements = schemaPart._elements;\n        if (hasObjectSchema(elements)) {\n            validateConfigSchema(moduleName, elements, thisKeyPath + '._elements');\n        }\n        if (schemaPart._validators) {\n            for (let validator of schemaPart._validators){\n                if (typeof validator !== 'function') {\n                    console.error(`${moduleName} has invalid validator for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: validators must be functions that return either ` + `undefined or an error string. Received ${validator}.`);\n                }\n            }\n        }\n        const valueType = schemaPart._type;\n        if (valueType && !Object.values(_types_js__rspack_import_0.Type).includes(valueType)) {\n            console.error(`${moduleName} has invalid type for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: the allowed types are ${Object.values(_types_js__rspack_import_0.Type).join(', ')}. ` + `Received '${valueType}'`);\n        }\n        if (Object.keys(schemaPart).every((k)=>[\n                '_description',\n                '_validators',\n                '_elements',\n                '_type'\n            ].includes(k)) && !keyPath.includes('._elements')) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: all config elements must have a default. ` + `Received ${JSON.stringify(schemaPart)}`);\n        }\n        if (elements && valueType && ![\n            _types_js__rspack_import_0.Type.Array,\n            _types_js__rspack_import_0.Type.Object\n        ].includes(valueType)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: the 'elements' key only works with '_type' equal to 'Array' or 'Object'. ` + `Received ${JSON.stringify(valueType)}`);\n        }\n    }\n}\nfunction getConfigForModule(moduleName, configState, tempConfigState) {\n    const schema = configState.schemas[moduleName];\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    validateStructure(schema, inputConfig, moduleName);\n    const config = setDefaults(schema, inputConfig);\n    runAllValidatorsInConfigTree(schema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction getConfigForModuleImplicitSchema(moduleName, configState, tempConfigState) {\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    const config = setDefaults(implicitConfigSchema, inputConfig);\n    runAllValidatorsInConfigTree(implicitConfigSchema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction mergeConfigsFor(moduleName, allConfigs) {\n    const allConfigsForModule = allConfigs.map(({ [moduleName]: c })=>c).filter((c)=>!!c);\n    return mergeConfigs(allConfigsForModule);\n}\n/**\n * Merges a whole list at once, accumulating into one destination.\n */ function mergeConfigs(configs) {\n    return configs.reduce((acc, config)=>(0,lodash_es__rspack_import_4[\"default\"])(acc, config, replaceArrays), {});\n}\n/**\n * Recursively check the provided config tree to make sure that all\n * of the provided properties exist in the schema, and that types are\n * correct. Does not run validators yet, since those will be run on\n * the config with the defaults filled in.\n */ function validateStructure(schema, config, keyPath = '') {\n    // validate each constituent element\n    for (const key of Object.keys(config)){\n        const value = config[key];\n        const thisKeyPath = keyPath + '.' + key;\n        const schemaPart = schema[key];\n        if (!schema.hasOwnProperty(key)) {\n            if (!(key === 'extensionSlots' && keyPath !== '')) {\n                logError(thisKeyPath, `Unknown config key '${thisKeyPath}' provided. Ignoring.`);\n            }\n            continue;\n        }\n        validateBranchStructure(schemaPart, value, thisKeyPath);\n    }\n}\nfunction validateBranchStructure(schemaPart, value, keyPath) {\n    checkType(keyPath, schemaPart._type, value);\n    if (isOrdinaryObject(value)) {\n        if (schemaPart._type === _types_js__rspack_import_0.Type.Object) {\n            // validate as freeform object\n            validateFreeformObjectStructure(schemaPart, value, keyPath);\n        } else if (!(schemaPart.hasOwnProperty('_default') || schemaPart.hasOwnProperty('_type'))) {\n            // validate as normal nested config\n            validateStructure(schemaPart, value, keyPath);\n        }\n    } else {\n        if (schemaPart._type === _types_js__rspack_import_0.Type.Array) {\n            validateArrayStructure(schemaPart, value, keyPath);\n        }\n    }\n}\nfunction validateFreeformObjectStructure(freeformObjectSchema, config, keyPath) {\n    if (freeformObjectSchema._elements) {\n        for (const key of Object.keys(config)){\n            const value = config[key];\n            validateBranchStructure(freeformObjectSchema._elements, value, `${keyPath}.${key}`);\n        }\n    }\n}\nfunction validateArrayStructure(arraySchema, value, keyPath) {\n    const validatedAsArray = checkType(keyPath, _types_js__rspack_import_0.Type.Array, value);\n    if (!validatedAsArray) {\n        return;\n    }\n    // if there is an array element object schema, verify that elements match it\n    if (hasObjectSchema(arraySchema._elements)) {\n        for(let i = 0; i < value.length; i++){\n            validateBranchStructure(arraySchema._elements, value[i], `${keyPath}[${i}]`);\n        }\n    }\n    for(let i = 0; i < value.length; i++){\n        checkType(`${keyPath}[${i}]`, arraySchema._elements?._type, value[i]);\n    }\n}\n/**\n * Run all the validators in the config tree. This should be run\n * on the config object after it has been filled in with all the defaults, since\n * higher-level validators may refer to default values.\n */ function runAllValidatorsInConfigTree(schema, config, keyPath = '') {\n    // If `!schema`, there should have been a structural validation error printed already.\n    if (schema) {\n        if (config !== schema._default) {\n            runValidators(keyPath, schema._validators, config);\n        }\n        if (isOrdinaryObject(config)) {\n            for (const key of Object.keys(config)){\n                const value = config[key];\n                const thisKeyPath = keyPath + '.' + key;\n                const schemaPart = schema[key];\n                if (schema._type === _types_js__rspack_import_0.Type.Object && schema._elements) {\n                    runAllValidatorsInConfigTree(schema._elements, value, thisKeyPath);\n                } else {\n                    runAllValidatorsInConfigTree(schemaPart, value, thisKeyPath);\n                }\n            }\n        } else if (Array.isArray(config) && schema._elements) {\n            for(let i = 0; i < config.length; i++){\n                runAllValidatorsInConfigTree(schema._elements, config[i], `${keyPath}[${i}]`);\n            }\n        }\n    }\n}\n/**\n * Run type validation for the value, logging any errors.\n * @returns true if validation passes, false otherwise\n */ function checkType(keyPath, _type, value) {\n    if (_type) {\n        const validator = {\n            Array: _validators_type_validators_js__rspack_import_1.isArray,\n            Boolean: _validators_type_validators_js__rspack_import_1.isBoolean,\n            ConceptUuid: _validators_type_validators_js__rspack_import_1.isUuid,\n            Number: _validators_type_validators_js__rspack_import_1.isNumber,\n            Object: _validators_type_validators_js__rspack_import_1.isObject,\n            String: _validators_type_validators_js__rspack_import_1.isString,\n            UUID: _validators_type_validators_js__rspack_import_1.isUuid,\n            PersonAttributeTypeUuid: _validators_type_validators_js__rspack_import_1.isUuid,\n            PatientIdentifierTypeUuid: _validators_type_validators_js__rspack_import_1.isUuid\n        };\n        return runValidators(keyPath, [\n            validator[_type]\n        ], value);\n    }\n    return true;\n}\n/**\n * Runs validators, logging errors.\n * @returns true if all pass, false otherwise.\n */ function runValidators(keyPath, validators, value) {\n    let returnValue = true;\n    if (validators) {\n        try {\n            for (let validator of validators){\n                const validatorResult = validator(value);\n                if (typeof validatorResult === 'string') {\n                    const message = typeof value === 'object' ? `Invalid configuration for ${keyPath}: ${validatorResult}` : `Invalid configuration value ${value} for ${keyPath}: ${validatorResult}`;\n                    logError(keyPath, message);\n                    returnValue = false;\n                }\n            }\n        } catch (e) {\n            console.error(`Skipping invalid validator at \"${keyPath}\". Encountered error\\n\\t${e}`);\n        }\n    }\n    return returnValue;\n}\n// Recursively fill in the config with values from the schema.\nconst setDefaults = (schema, inputConfig)=>{\n    const config = structuredClone(inputConfig);\n    if (!schema) {\n        return config;\n    }\n    for (const key of Object.keys(schema)){\n        const configPart = config[key];\n        const schemaPart = schema[key];\n        // The `schemaPart &&` clause of this `if` statement will only fail\n        // if the schema is very invalid. It is there to prevent the app from\n        // crashing completely, though it will produce unexpected behavior.\n        // If this happens, there should be legible errors in the console from\n        // the schema validator.\n        if (schemaPart && (schemaPart.hasOwnProperty('_type') || schemaPart.hasOwnProperty('_default'))) {\n            // We assume that schemaPart defines a config value, since it has\n            // a property `_type` or `_default`.\n            if (!config.hasOwnProperty(key)) {\n                config[key] = schemaPart['_default'];\n            }\n            // We also check if it is an object or array with object elements, in which case we recurse\n            const elements = schemaPart._elements;\n            if (configPart && hasObjectSchema(elements)) {\n                if (schemaPart._type === _types_js__rspack_import_0.Type.Array && Array.isArray(configPart)) {\n                    const configWithDefaults = configPart.map((conf)=>setDefaults(elements, conf));\n                    config[key] = configWithDefaults;\n                } else if (schemaPart._type === _types_js__rspack_import_0.Type.Object) {\n                    for (let objectKey of Object.keys(configPart)){\n                        configPart[objectKey] = setDefaults(elements, configPart[objectKey]);\n                    }\n                }\n            }\n        } else if (isOrdinaryObject(schemaPart)) {\n            // Since schemaPart has no property \"_type\", if it's an ordinary object\n            // (unlike, importantly, the validators array), we assume it is a parent config property.\n            // We recurse to config[key] and schema[key]. Default config[key] to {}.\n            const selectedConfigPart = configPart ?? {};\n            // There will have been a validation error already if configPart is not a plain object.\n            if (isOrdinaryObject(selectedConfigPart)) {\n                config[key] = setDefaults(schemaPart, selectedConfigPart);\n            }\n        }\n    }\n    return config;\n};\nfunction hasObjectSchema(elementsSchema) {\n    return !!elementsSchema && Object.keys(elementsSchema).filter((e)=>![\n            '_default',\n            '_validators'\n        ].includes(e)).length > 0;\n}\nfunction isOrdinaryObject(value) {\n    return typeof value === 'object' && !Array.isArray(value) && value !== null;\n}\n/** Keep track of which validation errors we have displayed. Each one should only be displayed once. */ let displayedValidationMessages = new Set();\nfunction logError(keyPath, message) {\n    const key = `${keyPath}:::${message}`;\n    // technically, this should not be possible, but because of how things wind-up transpiled, this isn't impossible\n    if (!displayedValidationMessages) {\n        displayedValidationMessages = new Set();\n    }\n    if (!displayedValidationMessages.has(key)) {\n        console.error(message);\n        displayedValidationMessages.add(key);\n    }\n}\n/**\n * Normally, configuration errors are only displayed once. This function clears the list of\n * displayed errors, so that they will be displayed again.\n *\n * @internal\n */ function clearConfigErrors(keyPath) {\n    if (keyPath) {\n        displayedValidationMessages.forEach((key)=>{\n            if (key.startsWith(keyPath)) {\n                displayedValidationMessages.delete(key);\n            }\n        });\n    } else {\n        displayedValidationMessages.clear();\n    }\n}\n/**\n * Cleans up all config store subscriptions and re-establishes them. This is primarily\n * useful for testing, where subscriptions set up at module load time need to be cleared\n * between tests to prevent infinite update loops. After clearing, subscriptions are\n * re-established so the config system continues to work normally.\n *\n * @internal\n */ function resetConfigSystem() {\n    configSubscriptions.forEach((unsubscribe)=>unsubscribe());\n    configSubscriptions.length = 0;\n    // Cached configs are keyed on input identity, so a test that reuses the same schema or config\n    // objects across cases would otherwise be served the previous case's result.\n    moduleConfigCache.clear();\n    extensionConfigCache.clear();\n    schemaValuesAndSourcesCache.clear();\n    implementerToolsModuleCache.clear();\n    lastDerivation = null;\n    entryOrigins = new WeakMap();\n    setupConfigSubscriptions();\n}\n/**\n * Copied over from esm-extensions. It rightly belongs to that module, but esm-config\n * cannot depend on esm-extensions.\n */ function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\n/**\n * The translation overrides schema is used in the implicit schema given to every module;\n * plus any additional translation namespaces (at time of writing, this is just 'core').\n */ const translationOverridesSchema = {\n    'Translation overrides': {\n        _description: 'Per-language overrides for frontend translations should be keyed by language code and each language dictionary contains the translation key and the display value',\n        _type: _types_js__rspack_import_0.Type.Object,\n        _default: {},\n        _validators: [\n            (0,_validators_validator_js__rspack_import_2.validator)((o)=>Object.keys(o).every((k)=>/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k)), (o)=>{\n                const badKeys = Object.keys(o).filter((k)=>!/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k));\n                return `The 'Translation overrides' object should have language codes for keys. Language codes must be in the form of a two-to-three letter language code optionally followed by a hyphen and a two-to-three letter country code. The following keys do not conform: ${badKeys.join(', ')}.`;\n            })\n        ]\n    }\n};\n/**\n * The implicitConfigSchema is implicitly included in every configuration schema\n */ const implicitConfigSchema = {\n    'Display conditions': {\n        privileges: {\n            _description: 'The privilege(s) the user must have to use this extension',\n            _type: _types_js__rspack_import_0.Type.Array,\n            _default: []\n        },\n        expression: {\n            _description: 'The expression that determines whether the extension is displayed',\n            _type: _types_js__rspack_import_0.Type.String,\n            _default: undefined\n        }\n    },\n    ...translationOverridesSchema\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-config/dist/module-config/module-config.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-config/dist/module-config/module-config.js?c3a5"],"sourcesContent":["/** @module @category Config */ import { cloneDeep, isEqual, mergeWith, omit as lodashOmit } from \"lodash-es\";\nimport { Type } from \"../types.js\";\nimport { isArray, isBoolean, isUuid, isNumber, isObject, isString } from \"../validators/type-validators.js\";\nimport { validator } from \"../validators/validator.js\";\nimport { configExtensionStore, configInternalStore, getConfigStore, getExtensionConfig, getExtensionSlotsConfigStore, getExtensionsConfigStore, clearConfigDerivationError, implementerToolsConfigStore, invalidateImplementerToolsConfig, recordConfigDerivationError, setImplementerToolsConfigRecomputer, temporaryConfigStore } from \"./state.js\";\n/**\n * Deep merge two objects, with right-side values taking precedence.\n * Arrays are replaced entirely (not merged by index), matching the\n * behavior of ramda's mergeDeepRight.\n */ function replaceArrays(_objValue, srcValue) {\n    if (Array.isArray(srcValue)) {\n        return srcValue;\n    }\n}\nfunction mergeDeepReplace(left, right) {\n    return mergeWith({}, left, right, replaceArrays);\n}\n/**\n * Store setup\n *\n *\n * Set up stores and subscriptions so that inputs get processed appropriately.\n *\n * There are *input* stores and *output* stores. The *input* stores\n * are configInternalStore, temporaryConfigStore, and configExtensionStore. The\n * output stores are set in the `compute...` functions. They are the module\n * config stores, the extension slot config stores (by module), the extension\n * config stores, and the implementer tools config store.\n *\n * This code sets up the subscriptions so that when an input store changes,\n * the correct set of output stores are updated.\n *\n * All `compute...` functions except `computeExtensionConfigs` are pure\n * (or are supposed to be), other than the fact that they all `setState`\n * store values at the end. `computeExtensionConfigs` calls `getGlobalStore`,\n * which creates stores.\n */ // Store unsubscribe functions to allow cleanup (e.g., in tests or hot module reloading)\nconst configSubscriptions = [];\n/**\n * Recomputes all configuration derived stores based on current state of input stores.\n * Called whenever any input store (configInternalStore, temporaryConfigStore, configExtensionStore) changes.\n */ function recomputeAllConfigs() {\n    const configState = configInternalStore.getState();\n    const tempConfigState = temporaryConfigStore.getState();\n    const extensionState = configExtensionStore.getState();\n    // Mounting an extension changes only `configExtensionStore`, which only the extension configs\n    // depend on, so the rest of the last derivation is reused.\n    const configInputsUnchanged = lastDerivation?.configState === configState && lastDerivation.tempConfigState === tempConfigState;\n    if (configInputsUnchanged) {\n        computeExtensionConfigs(configState, extensionState, tempConfigState, lastDerivation.slotConfigs, true);\n        return;\n    }\n    computeModuleConfig(configState, tempConfigState);\n    const slotConfigs = getExtensionSlotConfigs(configState, tempConfigState);\n    computeExtensionSlotConfigs(slotConfigs);\n    computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs, false);\n    // Recorded only after the outputs above are written, so a failure forces a full derivation next time.\n    lastDerivation = {\n        configState,\n        tempConfigState,\n        slotConfigs\n    };\n    // Last, because a failure here must not skip the outputs above. Only kept current while the\n    // implementer tools are watching it; otherwise derived on read.\n    invalidateImplementerToolsConfig();\n}\n/** The inputs the outputs were last fully derived from, compared by identity. */ let lastDerivation = null;\n/**\n * The mounted extension each extension config entry was derived for. An extension ID can be\n * mounted under a different module while its slot and ID stay the same, so an entry is only\n * current if its modules match too.\n */ let entryOrigins = new WeakMap();\nfunction setupConfigSubscriptions() {\n    // Registered here rather than at module load so that `resetConfigSystem` restores it.\n    setImplementerToolsConfigRecomputer(()=>computeImplementerToolsConfig(configInternalStore.getState(), temporaryConfigStore.getState()));\n    // Initial computation\n    recomputeAllConfigs();\n    // Subscribe to all input stores with a single handler\n    // This ensures we only recompute once even if multiple stores change simultaneously\n    configSubscriptions.push(configInternalStore.subscribe(recomputeAllConfigsSafely), temporaryConfigStore.subscribe(recomputeAllConfigsSafely), configExtensionStore.subscribe(recomputeAllConfigsSafely));\n}\n/** Ensure that we do not throw during a store subscription */ function recomputeAllConfigsSafely() {\n    clearConfigDerivationError();\n    try {\n        recomputeAllConfigs();\n    } catch (e) {\n        recordConfigDerivationError(e);\n        console.error('Failed to recompute the configuration', e);\n    }\n}\n// Set up subscriptions at module load time\nsetupConfigSubscriptions();\nconst moduleConfigCache = new Map();\nfunction computeModuleConfig(state, tempState) {\n    for (let moduleName of Object.keys(state.schemas)){\n        // At this point the schema could be either just the implicit schema or the actually\n        // defined schema. We run with just the implicit schema because we want to populate\n        // the config store with the translation overrides as soon as possible. In fact, the\n        // translation system will throw for Suspense until the translation overrides are\n        // available, which as of this writing blocks the schema definition from occurring\n        // for modules loaded based on their extensions.\n        const moduleStore = getConfigStore(moduleName);\n        const schema = state.schemas[moduleName];\n        const moduleLoaded = Boolean(state.moduleLoaded[moduleName]);\n        const cached = moduleConfigCache.get(moduleName);\n        let newState;\n        if (cached && cached.schema === schema && cached.moduleLoaded === moduleLoaded && cached.providedConfigs === state.providedConfigs && cached.temporaryConfig === tempState.config) {\n            newState = cached.state;\n        } else {\n            const config = moduleLoaded ? getConfigForModule(moduleName, state, tempState) : getConfigForModuleImplicitSchema(moduleName, state, tempState);\n            newState = {\n                translationOverridesLoaded: true,\n                loaded: moduleLoaded,\n                config\n            };\n            moduleConfigCache.set(moduleName, {\n                schema,\n                moduleLoaded,\n                providedConfigs: state.providedConfigs,\n                temporaryConfig: tempState.config,\n                state: newState\n            });\n        }\n        // Writing unconditionally would hand every `useConfig` consumer in the application a new\n        // object — and a re-render — whenever any module or extension anywhere is loaded.\n        const oldState = moduleStore.getState();\n        if (oldState.loaded !== newState.loaded || oldState.translationOverridesLoaded !== newState.translationOverridesLoaded || !isEqual(oldState.config, newState.config)) {\n            moduleStore.setState(newState);\n        }\n    }\n}\nfunction computeExtensionSlotConfigs(slotConfigs) {\n    const slotStore = getExtensionSlotsConfigStore();\n    const oldSlots = slotStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    for (const [slotName, config] of Object.entries(slotConfigs)){\n        const previous = oldSlots[slotName];\n        // Entries keep their identity when the configuration behind them hasn't changed, so that\n        // changing one slot's configuration doesn't invalidate every other configured slot.\n        if (previous?.loaded && isEqual(previous.config, config)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                loaded: true,\n                config\n            };\n            changed = true;\n        }\n    }\n    // Built from scratch rather than merged over the previous state: a slot whose configuration\n    // has been removed — clearing the temporary config, say — has to lose its entry, or the old\n    // configuration stays in force until the page is reloaded.\n    if (changed || Object.keys(oldSlots).length !== Object.keys(slots).length) {\n        slotStore.setState({\n            slots\n        });\n    }\n}\nfunction computeImplementerToolsConfig(state, tempConfigState) {\n    const oldState = implementerToolsConfigStore.getState();\n    const config = getImplementerToolsConfig(state, tempConfigState);\n    const newState = {\n        config\n    };\n    // Use deep equality on the actual config content, not the wrapper object\n    if (!isEqual(oldState.config, newState.config)) {\n        implementerToolsConfigStore.setState(newState);\n    }\n}\nfunction computeExtensionConfigs(configState, extensionState, tempConfigState, slotConfigs, configInputsUnchanged) {\n    const extensionsConfigStore = getExtensionsConfigStore();\n    const oldConfigs = extensionsConfigStore.getState().configs;\n    const configs = {};\n    let changed = false;\n    let entryCount = 0;\n    // We assume that the module schema has already been defined, since the extension\n    // it contains is mounted.\n    for (let extension of extensionState.mountedExtensions){\n        const previous = oldConfigs[extension.slotName]?.[extension.extensionId];\n        let entry;\n        const origin = previous && entryOrigins.get(previous);\n        if (configInputsUnchanged && previous?.loaded && origin?.slotModuleName === extension.slotModuleName && origin.extensionModuleName === extension.extensionModuleName) {\n            // Derived from these same inputs by the previous run, so it is still current.\n            entry = previous;\n        } else {\n            const config = computeExtensionConfig(extension.slotModuleName, extension.extensionModuleName, extension.slotName, extension.extensionId, configState, tempConfigState, slotConfigs[extension.slotName]);\n            // Entries keep their identity when the configuration behind them hasn't changed, so that\n            // mounting one extension doesn't hand every other mounted extension a new config object.\n            entry = previous?.loaded && isEqual(previous.config, config) ? previous : {\n                config,\n                loaded: true\n            };\n        }\n        entryOrigins.set(entry, extension);\n        if (entry !== previous) {\n            changed = true;\n        }\n        if (!configs[extension.slotName]) {\n            configs[extension.slotName] = {};\n        }\n        configs[extension.slotName][extension.extensionId] = entry;\n        entryCount++;\n    }\n    // Slots keep their identity too when none of their entries changed. Subscribers compare these\n    // per-slot objects to work out which slots to re-derive, so handing out a fresh one for every\n    // slot on every write would mark every slot with a mounted extension dirty.\n    for (const [slotName, slotConfigs] of Object.entries(configs)){\n        const previousSlot = oldConfigs[slotName];\n        if (previousSlot && Object.keys(previousSlot).length === Object.keys(slotConfigs).length && Object.entries(slotConfigs).every(([extensionId, entry])=>previousSlot[extensionId] === entry)) {\n            configs[slotName] = previousSlot;\n        }\n    }\n    if (!changed) {\n        // Nothing was added or altered, but an extension may have unmounted, which only shows up as a\n        // missing entry.\n        changed = Object.keys(oldConfigs).length !== Object.keys(configs).length || Object.values(oldConfigs).reduce((total, slot)=>total + Object.keys(slot).length, 0) !== entryCount;\n    }\n    if (changed) {\n        extensionsConfigStore.setState({\n            configs\n        });\n    }\n}\n/*\n * API\n *\n */ /**\n * This defines a configuration schema for a module. The schema tells the\n * configuration system how the module can be configured. It specifies\n * what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param moduleName Name of the module the schema is being defined for. Generally\n *   should be the one in which the `defineConfigSchema` call takes place.\n * @param schema The config schema for the module\n */ export function defineConfigSchema(moduleName, schema) {\n    validateConfigSchema(moduleName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: enhancedSchema\n            },\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module exists. This allows config to be\n * processed, while still allowing the extension system to know whether the module has\n * actually had its front bundle executed yet.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ export function registerModuleWithConfigSystem(moduleName) {\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [moduleName]: implicitConfigSchema\n            }\n        }));\n}\n/**\n * This alerts the configuration system that a module has been loaded.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param moduleName\n */ export function registerModuleLoad(moduleName) {\n    configInternalStore.setState((state)=>({\n            ...state,\n            moduleLoaded: {\n                ...state.moduleLoaded,\n                [moduleName]: true\n            }\n        }));\n}\n/**\n * This allows the config system to support translation overrides for namespaces that\n * do not correspond to modules.\n *\n * This should only be used in esm-app-shell.\n *\n * @internal\n * @param namespace\n */ export function registerTranslationNamespace(namespace) {\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [namespace]: translationOverridesSchema\n            }\n        }));\n}\n/**\n * This defines a configuration schema for an extension. When a schema is defined\n * for an extension, that extension will receive the configuration corresponding\n * to that schema, rather than the configuration corresponding to the module\n * in which it is defined.\n *\n * The schema tells the configuration system how the module can be configured.\n * It specifies what makes configuration valid or invalid.\n *\n * See [Configuration System](https://o3-docs.openmrs.org/en-US/docs/configuration-system)\n * for more information about defining a config schema.\n *\n * @param extensionName Name of the extension the schema is being defined for.\n *   Should match the `name` of one of the `extensions` entries defined in\n *   the app's `routes.json` file.\n * @param schema The config schema for the extension\n */ export function defineExtensionConfigSchema(extensionName, schema) {\n    validateConfigSchema(extensionName, schema);\n    const enhancedSchema = mergeDeepReplace(schema, implicitConfigSchema);\n    const state = configInternalStore.getState();\n    if (state.schemas[extensionName]) {\n        console.error(`Config schema for extension ${extensionName} already exists. If there are multiple extensions with this same name, one will probably crash.`);\n    }\n    configInternalStore.setState((state)=>({\n            ...state,\n            schemas: {\n                ...state.schemas,\n                [extensionName]: enhancedSchema\n            }\n        }));\n}\n/**\n * Provides configuration values programmatically. This is an alternative to\n * providing configuration through the config-file. Configuration provided this\n * way will be merged with configuration from other sources.\n *\n * @param config A configuration object to merge into the existing configuration.\n * @param sourceName An optional name to identify the source of this configuration,\n *   used for debugging purposes. Defaults to 'provided'.\n */ export function provide(config, sourceName = 'provided') {\n    configInternalStore.setState((state)=>({\n            ...state,\n            providedConfigs: [\n                ...state.providedConfigs,\n                {\n                    source: sourceName,\n                    config\n                }\n            ]\n        }));\n}\n/**\n * Resolves with `select(state)` as soon as the store's state satisfies `ready`, leaving no\n * subscription behind: nothing subscribes at all when the store is already ready. That matters\n * because `getConfig` runs on every HTTP request, and a subscription that outlives its promise\n * both retains its closure forever and slows down every later write to that store.\n */ function whenStoreReady(store, ready, select) {\n    return new Promise((resolve)=>{\n        let unsubscribe;\n        let resolved = false;\n        function update(state) {\n            if (!resolved && ready(state)) {\n                resolved = true;\n                resolve(select(state));\n                unsubscribe?.();\n            }\n        }\n        update(store.getState());\n        if (!resolved) {\n            unsubscribe = store.subscribe(update);\n        }\n    });\n}\n/**\n * A promise-based way to access the config as soon as it is fully loaded.\n * If it is already loaded, resolves the config in its present state.\n *\n * This is a useful function if you need to get the config in the course\n * of the execution of a function.\n *\n * @param moduleName The name of the module for which to look up the config\n */ export function getConfig(moduleName) {\n    return whenStoreReady(getConfigStore(moduleName), (state)=>Boolean(state.loaded && state.config), (state)=>lodashOmit(state.config, [\n            'Display conditions',\n            'Translation overrides'\n        ]));\n}\n/**\n * Retrieves translation overrides for an extension, optionally scoped to a specific\n * extension slot. When called with only a module name, retrieves module-level overrides.\n * Translation overrides allow customizing translated strings without modifying the\n * original translation files.\n *\n * @param moduleName The name of the module providing the translation context.\n * @param slotName Optional extension slot name to include slot-specific overrides.\n * @param extensionId Optional extension ID to include extension-specific overrides.\n * @returns A Promise resolving to an array of translation override objects.\n *\n * @internal\n */ export function getTranslationOverrides(moduleName, slotName, extensionId) {\n    const promises = [\n        whenStoreReady(getConfigStore(moduleName), (state)=>Boolean(state.translationOverridesLoaded && state.config), (state)=>state.config['Translation overrides'] ?? {})\n    ];\n    if (slotName && extensionId) {\n        promises.push(whenStoreReady(getExtensionConfig(slotName, extensionId), (state)=>Boolean(state.loaded && state.config), (state)=>state.config['Translation overrides'] ?? {}));\n    }\n    return Promise.all(promises);\n}\n/**\n * Validate and interpolate defaults for `providedConfig` according to `schema`\n *\n * @param schema  a configuration schema\n * @param providedConfig  an object of config values (without the top-level module name)\n * @param keyPathContext  a dot-separated string which helps the user figure out where\n *     the provided config came from\n * @returns The validated and processed configuration object with defaults applied.\n * @internal\n */ export function processConfig(schema, providedConfig, keyPathContext) {\n    validateStructure(schema, providedConfig, keyPathContext);\n    const config = setDefaults(schema, providedConfig);\n    runAllValidatorsInConfigTree(schema, config, keyPathContext);\n    return config;\n}\nconst extensionConfigCache = new Map();\n/**\n * Returns the configuration for an extension. This configuration is specific\n * to the slot in which it is mounted, and its ID within that slot.\n *\n * The schema for that configuration is the extension schema. If no extension\n * schema has been provided, the schema used is the schema of the module in\n * which the extension is defined.\n *\n * @param slotModuleName The name of the module which defines the extension slot\n * @param extensionModuleName The name of the module which defines the extension (and therefore the config schema)\n * @param slotName The name of the extension slot where the extension is mounted\n * @param extensionId The ID of the extension in its slot\n * @param slotConfig The slot's configuration, gathered from every module that configures it\n */ function computeExtensionConfig(slotModuleName, extensionModuleName, slotName, extensionId, configState, tempConfigState, slotConfig) {\n    const extensionName = getExtensionNameFromId(extensionId);\n    const extensionConfigSchema = configState.schemas[extensionName];\n    // JSON string of these elements should be unique-per-extension\n    const cacheKey = JSON.stringify([\n        slotName,\n        extensionId,\n        slotModuleName,\n        extensionModuleName\n    ]);\n    const cached = extensionConfigCache.get(cacheKey);\n    if (cached && cached.extensionSchema === extensionConfigSchema && cached.extensionModuleSchema === configState.schemas[extensionModuleName] && cached.providedConfigs === configState.providedConfigs && cached.temporaryConfig === tempConfigState.config) {\n        return cached.config;\n    }\n    const nameOfSchemaSource = extensionConfigSchema ? extensionName : extensionModuleName;\n    const providedConfigs = getProvidedConfigs(configState, tempConfigState);\n    const sharedOverride = slotConfig?.configure?.[extensionId] ?? {};\n    const slotModuleConfig = mergeConfigsFor(slotModuleName, providedConfigs);\n    const configOverride = slotModuleConfig?.extensionSlots?.[slotName]?.configure?.[extensionId] ?? {};\n    const extensionConfig = mergeConfigsFor(nameOfSchemaSource, providedConfigs);\n    const combinedConfig = mergeConfigs([\n        extensionConfig,\n        sharedOverride,\n        configOverride\n    ]);\n    const schema = extensionConfigSchema ?? configState.schemas[extensionModuleName];\n    validateStructure(schema, combinedConfig, nameOfSchemaSource);\n    const config = setDefaults(schema, combinedConfig);\n    runAllValidatorsInConfigTree(schema, config, nameOfSchemaSource);\n    delete config.extensionSlots;\n    extensionConfigCache.set(cacheKey, {\n        extensionSchema: extensionConfigSchema,\n        extensionModuleSchema: configState.schemas[extensionModuleName],\n        providedConfigs: configState.providedConfigs,\n        temporaryConfig: tempConfigState.config,\n        config\n    });\n    return config;\n}\nconst implementerToolsModuleCache = new Map();\nfunction getImplementerToolsConfig(configState, tempConfigState) {\n    const annotatedSchemas = getAllSchemasWithValuesAndSources(configState.schemas);\n    const configsAndSources = [\n        ...configState.providedConfigs.map((c)=>[\n                c.config,\n                c.source\n            ]),\n        [\n            tempConfigState.config,\n            'temporary config'\n        ]\n    ];\n    // A module can be configured without having declared a schema, so the module list is the union\n    // of both rather than just the schemas.\n    const moduleNames = new Set(Object.keys(annotatedSchemas));\n    for (const [config] of configsAndSources){\n        for (const moduleName of Object.keys(config)){\n            moduleNames.add(moduleName);\n        }\n    }\n    const result = {};\n    for (const moduleName of moduleNames){\n        const annotatedSchema = annotatedSchemas[moduleName];\n        const configSlices = configsAndSources.map(([config])=>config[moduleName]);\n        const sources = configsAndSources.map(([, source])=>source);\n        const cached = implementerToolsModuleCache.get(moduleName);\n        if (cached && cached.annotatedSchema === annotatedSchema && cached.configSlices.length === configSlices.length && cached.configSlices.every((slice, i)=>slice === configSlices[i]) && cached.sources.every((source, i)=>source === sources[i])) {\n            result[moduleName] = cached.result;\n            continue;\n        }\n        let merged = annotatedSchema ?? {};\n        configsAndSources.forEach(([, source], i)=>{\n            const slice = configSlices[i];\n            if (slice !== undefined) {\n                merged = mergeDeepReplace(merged, createValuesAndSourcesTree(slice, source));\n            }\n        });\n        implementerToolsModuleCache.set(moduleName, {\n            annotatedSchema,\n            configSlices,\n            sources,\n            result: merged\n        });\n        result[moduleName] = merged;\n    }\n    return result;\n}\n/**\n * Caching per module is what stops the walk being quadratic: defining one module's schema\n * recomputes every module.\n *\n * A module with no configuration of its own is published straight from this cache, so nothing may\n * mutate a tree it reads out of the implementer tools config — it is the cache entry.\n */ const schemaValuesAndSourcesCache = new Map();\nfunction getAllSchemasWithValuesAndSources(schemas) {\n    const result = {};\n    for (const [moduleName, schema] of Object.entries(schemas)){\n        const cached = schemaValuesAndSourcesCache.get(moduleName);\n        if (cached && cached.schema === schema) {\n            result[moduleName] = cached.annotated;\n        } else {\n            const annotated = getSchemaWithValuesAndSources(cloneDeep(schema));\n            schemaValuesAndSourcesCache.set(moduleName, {\n                schema,\n                annotated\n            });\n            result[moduleName] = annotated;\n        }\n    }\n    return result;\n}\nfunction getSchemaWithValuesAndSources(schema) {\n    if (schema.hasOwnProperty('_default')) {\n        return {\n            ...schema,\n            _value: schema._default,\n            _source: 'default'\n        };\n    } else if (isOrdinaryObject(schema)) {\n        return Object.keys(schema).reduce((obj, key)=>{\n            obj[key] = getSchemaWithValuesAndSources(schema[key]);\n            return obj;\n        }, {});\n    } else {\n        // at this point, the schema is bad and an error will have been logged during schema validation\n        return {};\n    }\n}\nfunction createValuesAndSourcesTree(config, source) {\n    if (isOrdinaryObject(config)) {\n        return Object.keys(config).reduce((obj, key)=>{\n            obj[key] = createValuesAndSourcesTree(config[key], source);\n            return obj;\n        }, {});\n    } else {\n        return {\n            _value: config,\n            _source: source\n        };\n    }\n}\nfunction getExtensionSlotConfigs(configState, tempConfigState) {\n    const allConfigs = mergeConfigs(getProvidedConfigs(configState, tempConfigState));\n    const slotConfigPerModule = Object.keys(allConfigs).reduce((obj, key)=>{\n        if (allConfigs[key]?.extensionSlots) {\n            obj[key] = allConfigs[key]?.extensionSlots;\n        }\n        return obj;\n    }, {});\n    validateAllExtensionSlotConfigs(slotConfigPerModule);\n    const slotConfigs = {};\n    const configureBlocks = {};\n    for (const configBySlotName of Object.values(slotConfigPerModule)){\n        for (const [slotName, config] of Object.entries(configBySlotName)){\n            slotConfigs[slotName] = config;\n            if (config.configure) {\n                var _configureBlocks, _slotName;\n                ((_configureBlocks = configureBlocks)[_slotName = slotName] ?? (_configureBlocks[_slotName] = [])).push(config.configure);\n            }\n        }\n    }\n    for (const [slotName, blocks] of Object.entries(configureBlocks)){\n        const configure = blocks.length === 1 ? blocks[0] : mergeConfigs(blocks);\n        if (slotConfigs[slotName].configure !== configure) {\n            slotConfigs[slotName] = {\n                ...slotConfigs[slotName],\n                configure\n            };\n        }\n    }\n    return slotConfigs;\n}\nfunction validateAllExtensionSlotConfigs(slotConfigPerModule) {\n    for (let [moduleName, configBySlotName] of Object.entries(slotConfigPerModule)){\n        for (let [slotName, config] of Object.entries(configBySlotName)){\n            validateExtensionSlotConfig(config, moduleName, slotName);\n        }\n    }\n}\nfunction validateExtensionSlotConfig(config, moduleName, slotName) {\n    const keyPath = `${moduleName}.extensionSlots.${slotName}`;\n    const errorPrefix = `Extension slot config '${keyPath}'`;\n    const invalidKeys = Object.keys(config).filter((k)=>![\n            'add',\n            'remove',\n            'order',\n            'configure'\n        ].includes(k));\n    if (invalidKeys.length) {\n        logError(keyPath, errorPrefix + `' contains invalid keys '${invalidKeys.join(\"', '\")}'`);\n    }\n    if (config.add) {\n        if (!Array.isArray(config.add) || !config.add.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.add' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.remove) {\n        if (!Array.isArray(config.remove) || !config.remove.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.remove' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.order) {\n        if (!Array.isArray(config.order) || !config.order.every((n)=>typeof n === 'string')) {\n            logError(keyPath, errorPrefix + `.order' is invalid. Must be an array of strings (extension IDs)`);\n        }\n    }\n    if (config.configure) {\n        if (!isOrdinaryObject(config.configure)) {\n            logError(keyPath, errorPrefix + `.configure' is invalid. Must be an object with extension IDs for keys`);\n        }\n    }\n}\nfunction getProvidedConfigs(configState, tempConfigState) {\n    return [\n        ...configState.providedConfigs.map((c)=>c.config),\n        tempConfigState.config\n    ];\n}\n/**\n * Validates the config schema for a module. Since problems identified here are programming errors\n * that hopefully will be caught during development, this function logs errors to the console directly;\n * it's fine if we spam the user with these errors.\n */ function validateConfigSchema(moduleName, schema, keyPath = '') {\n    const updateMessage = `Please verify that you are running the latest version and, if so, alert the maintainer.`;\n    for (const key of Object.keys(schema).filter((k)=>!k.startsWith('_'))){\n        const thisKeyPath = keyPath + (keyPath && '.') + key;\n        const schemaPart = schema[key];\n        if (thisKeyPath === 'Display conditions') {\n            console.error(`${moduleName} declares a configuration option called \"Display conditions\"; the \"Display conditions\" option is a reserved name. ${updateMessage}`);\n        }\n        if (thisKeyPath === 'Translation overrides') {\n            console.error(`${moduleName} declares a configuration option called \"Translation overrides\"; the \"Translation overrides\" option is a reserved name. ${updateMessage}`);\n        }\n        if (!isOrdinaryObject(schemaPart)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}`);\n            continue;\n        }\n        if (!schemaPart.hasOwnProperty('_default')) {\n            // recurse for nested config keys\n            validateConfigSchema(moduleName, schemaPart, thisKeyPath);\n        }\n        const elements = schemaPart._elements;\n        if (hasObjectSchema(elements)) {\n            validateConfigSchema(moduleName, elements, thisKeyPath + '._elements');\n        }\n        if (schemaPart._validators) {\n            for (let validator of schemaPart._validators){\n                if (typeof validator !== 'function') {\n                    console.error(`${moduleName} has invalid validator for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: validators must be functions that return either ` + `undefined or an error string. Received ${validator}.`);\n                }\n            }\n        }\n        const valueType = schemaPart._type;\n        if (valueType && !Object.values(Type).includes(valueType)) {\n            console.error(`${moduleName} has invalid type for key '${thisKeyPath}' ${updateMessage}.` + `\\n\\nIf you're the maintainer: the allowed types are ${Object.values(Type).join(', ')}. ` + `Received '${valueType}'`);\n        }\n        if (Object.keys(schemaPart).every((k)=>[\n                '_description',\n                '_validators',\n                '_elements',\n                '_type'\n            ].includes(k)) && !keyPath.includes('._elements')) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: all config elements must have a default. ` + `Received ${JSON.stringify(schemaPart)}`);\n        }\n        if (elements && valueType && ![\n            Type.Array,\n            Type.Object\n        ].includes(valueType)) {\n            console.error(`${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}.` + `\\n\\nIf you're the maintainer: the 'elements' key only works with '_type' equal to 'Array' or 'Object'. ` + `Received ${JSON.stringify(valueType)}`);\n        }\n    }\n}\nfunction getConfigForModule(moduleName, configState, tempConfigState) {\n    const schema = configState.schemas[moduleName];\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    validateStructure(schema, inputConfig, moduleName);\n    const config = setDefaults(schema, inputConfig);\n    runAllValidatorsInConfigTree(schema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction getConfigForModuleImplicitSchema(moduleName, configState, tempConfigState) {\n    const inputConfig = mergeConfigsFor(moduleName, getProvidedConfigs(configState, tempConfigState));\n    const config = setDefaults(implicitConfigSchema, inputConfig);\n    runAllValidatorsInConfigTree(implicitConfigSchema, config, moduleName);\n    delete config.extensionSlots;\n    return config;\n}\nfunction mergeConfigsFor(moduleName, allConfigs) {\n    const allConfigsForModule = allConfigs.map(({ [moduleName]: c })=>c).filter((c)=>!!c);\n    return mergeConfigs(allConfigsForModule);\n}\n/**\n * Merges a whole list at once, accumulating into one destination.\n */ function mergeConfigs(configs) {\n    return configs.reduce((acc, config)=>mergeWith(acc, config, replaceArrays), {});\n}\n/**\n * Recursively check the provided config tree to make sure that all\n * of the provided properties exist in the schema, and that types are\n * correct. Does not run validators yet, since those will be run on\n * the config with the defaults filled in.\n */ function validateStructure(schema, config, keyPath = '') {\n    // validate each constituent element\n    for (const key of Object.keys(config)){\n        const value = config[key];\n        const thisKeyPath = keyPath + '.' + key;\n        const schemaPart = schema[key];\n        if (!schema.hasOwnProperty(key)) {\n            if (!(key === 'extensionSlots' && keyPath !== '')) {\n                logError(thisKeyPath, `Unknown config key '${thisKeyPath}' provided. Ignoring.`);\n            }\n            continue;\n        }\n        validateBranchStructure(schemaPart, value, thisKeyPath);\n    }\n}\nfunction validateBranchStructure(schemaPart, value, keyPath) {\n    checkType(keyPath, schemaPart._type, value);\n    if (isOrdinaryObject(value)) {\n        if (schemaPart._type === Type.Object) {\n            // validate as freeform object\n            validateFreeformObjectStructure(schemaPart, value, keyPath);\n        } else if (!(schemaPart.hasOwnProperty('_default') || schemaPart.hasOwnProperty('_type'))) {\n            // validate as normal nested config\n            validateStructure(schemaPart, value, keyPath);\n        }\n    } else {\n        if (schemaPart._type === Type.Array) {\n            validateArrayStructure(schemaPart, value, keyPath);\n        }\n    }\n}\nfunction validateFreeformObjectStructure(freeformObjectSchema, config, keyPath) {\n    if (freeformObjectSchema._elements) {\n        for (const key of Object.keys(config)){\n            const value = config[key];\n            validateBranchStructure(freeformObjectSchema._elements, value, `${keyPath}.${key}`);\n        }\n    }\n}\nfunction validateArrayStructure(arraySchema, value, keyPath) {\n    const validatedAsArray = checkType(keyPath, Type.Array, value);\n    if (!validatedAsArray) {\n        return;\n    }\n    // if there is an array element object schema, verify that elements match it\n    if (hasObjectSchema(arraySchema._elements)) {\n        for(let i = 0; i < value.length; i++){\n            validateBranchStructure(arraySchema._elements, value[i], `${keyPath}[${i}]`);\n        }\n    }\n    for(let i = 0; i < value.length; i++){\n        checkType(`${keyPath}[${i}]`, arraySchema._elements?._type, value[i]);\n    }\n}\n/**\n * Run all the validators in the config tree. This should be run\n * on the config object after it has been filled in with all the defaults, since\n * higher-level validators may refer to default values.\n */ function runAllValidatorsInConfigTree(schema, config, keyPath = '') {\n    // If `!schema`, there should have been a structural validation error printed already.\n    if (schema) {\n        if (config !== schema._default) {\n            runValidators(keyPath, schema._validators, config);\n        }\n        if (isOrdinaryObject(config)) {\n            for (const key of Object.keys(config)){\n                const value = config[key];\n                const thisKeyPath = keyPath + '.' + key;\n                const schemaPart = schema[key];\n                if (schema._type === Type.Object && schema._elements) {\n                    runAllValidatorsInConfigTree(schema._elements, value, thisKeyPath);\n                } else {\n                    runAllValidatorsInConfigTree(schemaPart, value, thisKeyPath);\n                }\n            }\n        } else if (Array.isArray(config) && schema._elements) {\n            for(let i = 0; i < config.length; i++){\n                runAllValidatorsInConfigTree(schema._elements, config[i], `${keyPath}[${i}]`);\n            }\n        }\n    }\n}\n/**\n * Run type validation for the value, logging any errors.\n * @returns true if validation passes, false otherwise\n */ function checkType(keyPath, _type, value) {\n    if (_type) {\n        const validator = {\n            Array: isArray,\n            Boolean: isBoolean,\n            ConceptUuid: isUuid,\n            Number: isNumber,\n            Object: isObject,\n            String: isString,\n            UUID: isUuid,\n            PersonAttributeTypeUuid: isUuid,\n            PatientIdentifierTypeUuid: isUuid\n        };\n        return runValidators(keyPath, [\n            validator[_type]\n        ], value);\n    }\n    return true;\n}\n/**\n * Runs validators, logging errors.\n * @returns true if all pass, false otherwise.\n */ function runValidators(keyPath, validators, value) {\n    let returnValue = true;\n    if (validators) {\n        try {\n            for (let validator of validators){\n                const validatorResult = validator(value);\n                if (typeof validatorResult === 'string') {\n                    const message = typeof value === 'object' ? `Invalid configuration for ${keyPath}: ${validatorResult}` : `Invalid configuration value ${value} for ${keyPath}: ${validatorResult}`;\n                    logError(keyPath, message);\n                    returnValue = false;\n                }\n            }\n        } catch (e) {\n            console.error(`Skipping invalid validator at \"${keyPath}\". Encountered error\\n\\t${e}`);\n        }\n    }\n    return returnValue;\n}\n// Recursively fill in the config with values from the schema.\nconst setDefaults = (schema, inputConfig)=>{\n    const config = structuredClone(inputConfig);\n    if (!schema) {\n        return config;\n    }\n    for (const key of Object.keys(schema)){\n        const configPart = config[key];\n        const schemaPart = schema[key];\n        // The `schemaPart &&` clause of this `if` statement will only fail\n        // if the schema is very invalid. It is there to prevent the app from\n        // crashing completely, though it will produce unexpected behavior.\n        // If this happens, there should be legible errors in the console from\n        // the schema validator.\n        if (schemaPart && (schemaPart.hasOwnProperty('_type') || schemaPart.hasOwnProperty('_default'))) {\n            // We assume that schemaPart defines a config value, since it has\n            // a property `_type` or `_default`.\n            if (!config.hasOwnProperty(key)) {\n                config[key] = schemaPart['_default'];\n            }\n            // We also check if it is an object or array with object elements, in which case we recurse\n            const elements = schemaPart._elements;\n            if (configPart && hasObjectSchema(elements)) {\n                if (schemaPart._type === Type.Array && Array.isArray(configPart)) {\n                    const configWithDefaults = configPart.map((conf)=>setDefaults(elements, conf));\n                    config[key] = configWithDefaults;\n                } else if (schemaPart._type === Type.Object) {\n                    for (let objectKey of Object.keys(configPart)){\n                        configPart[objectKey] = setDefaults(elements, configPart[objectKey]);\n                    }\n                }\n            }\n        } else if (isOrdinaryObject(schemaPart)) {\n            // Since schemaPart has no property \"_type\", if it's an ordinary object\n            // (unlike, importantly, the validators array), we assume it is a parent config property.\n            // We recurse to config[key] and schema[key]. Default config[key] to {}.\n            const selectedConfigPart = configPart ?? {};\n            // There will have been a validation error already if configPart is not a plain object.\n            if (isOrdinaryObject(selectedConfigPart)) {\n                config[key] = setDefaults(schemaPart, selectedConfigPart);\n            }\n        }\n    }\n    return config;\n};\nfunction hasObjectSchema(elementsSchema) {\n    return !!elementsSchema && Object.keys(elementsSchema).filter((e)=>![\n            '_default',\n            '_validators'\n        ].includes(e)).length > 0;\n}\nfunction isOrdinaryObject(value) {\n    return typeof value === 'object' && !Array.isArray(value) && value !== null;\n}\n/** Keep track of which validation errors we have displayed. Each one should only be displayed once. */ let displayedValidationMessages = new Set();\nfunction logError(keyPath, message) {\n    const key = `${keyPath}:::${message}`;\n    // technically, this should not be possible, but because of how things wind-up transpiled, this isn't impossible\n    if (!displayedValidationMessages) {\n        displayedValidationMessages = new Set();\n    }\n    if (!displayedValidationMessages.has(key)) {\n        console.error(message);\n        displayedValidationMessages.add(key);\n    }\n}\n/**\n * Normally, configuration errors are only displayed once. This function clears the list of\n * displayed errors, so that they will be displayed again.\n *\n * @internal\n */ export function clearConfigErrors(keyPath) {\n    if (keyPath) {\n        displayedValidationMessages.forEach((key)=>{\n            if (key.startsWith(keyPath)) {\n                displayedValidationMessages.delete(key);\n            }\n        });\n    } else {\n        displayedValidationMessages.clear();\n    }\n}\n/**\n * Cleans up all config store subscriptions and re-establishes them. This is primarily\n * useful for testing, where subscriptions set up at module load time need to be cleared\n * between tests to prevent infinite update loops. After clearing, subscriptions are\n * re-established so the config system continues to work normally.\n *\n * @internal\n */ export function resetConfigSystem() {\n    configSubscriptions.forEach((unsubscribe)=>unsubscribe());\n    configSubscriptions.length = 0;\n    // Cached configs are keyed on input identity, so a test that reuses the same schema or config\n    // objects across cases would otherwise be served the previous case's result.\n    moduleConfigCache.clear();\n    extensionConfigCache.clear();\n    schemaValuesAndSourcesCache.clear();\n    implementerToolsModuleCache.clear();\n    lastDerivation = null;\n    entryOrigins = new WeakMap();\n    setupConfigSubscriptions();\n}\n/**\n * Copied over from esm-extensions. It rightly belongs to that module, but esm-config\n * cannot depend on esm-extensions.\n */ function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\n/**\n * The translation overrides schema is used in the implicit schema given to every module;\n * plus any additional translation namespaces (at time of writing, this is just 'core').\n */ const translationOverridesSchema = {\n    'Translation overrides': {\n        _description: 'Per-language overrides for frontend translations should be keyed by language code and each language dictionary contains the translation key and the display value',\n        _type: Type.Object,\n        _default: {},\n        _validators: [\n            validator((o)=>Object.keys(o).every((k)=>/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k)), (o)=>{\n                const badKeys = Object.keys(o).filter((k)=>!/^[a-z]{2,3}(-[A-Z]{2,3})?$/.test(k));\n                return `The 'Translation overrides' object should have language codes for keys. Language codes must be in the form of a two-to-three letter language code optionally followed by a hyphen and a two-to-three letter country code. The following keys do not conform: ${badKeys.join(', ')}.`;\n            })\n        ]\n    }\n};\n/**\n * The implicitConfigSchema is implicitly included in every configuration schema\n */ const implicitConfigSchema = {\n    'Display conditions': {\n        privileges: {\n            _description: 'The privilege(s) the user must have to use this extension',\n            _type: Type.Array,\n            _default: []\n        },\n        expression: {\n            _description: 'The expression that determines whether the extension is displayed',\n            _type: Type.String,\n            _default: undefined\n        }\n    },\n    ...translationOverridesSchema\n};\n"],"names":["cloneDeep","isEqual","mergeWith","omit","lodashOmit","Type","isArray","isBoolean","isUuid","isNumber","isObject","isString","validator","configExtensionStore","configInternalStore","getConfigStore","getExtensionConfig","getExtensionSlotsConfigStore","getExtensionsConfigStore","clearConfigDerivationError","implementerToolsConfigStore","invalidateImplementerToolsConfig","recordConfigDerivationError","setImplementerToolsConfigRecomputer","temporaryConfigStore","replaceArrays","_objValue","srcValue","Array","mergeDeepReplace","left","right","configSubscriptions","recomputeAllConfigs","configState","tempConfigState","extensionState","configInputsUnchanged","lastDerivation","computeExtensionConfigs","computeModuleConfig","slotConfigs","getExtensionSlotConfigs","computeExtensionSlotConfigs","entryOrigins","WeakMap","setupConfigSubscriptions","computeImplementerToolsConfig","recomputeAllConfigsSafely","e","console","moduleConfigCache","Map","state","tempState","moduleName","Object","moduleStore","schema","moduleLoaded","Boolean","cached","newState","config","getConfigForModule","getConfigForModuleImplicitSchema","oldState","slotStore","oldSlots","slots","changed","slotName","previous","getImplementerToolsConfig","extensionsConfigStore","oldConfigs","configs","entryCount","extension","entry","origin","computeExtensionConfig","previousSlot","extensionId","total","slot","defineConfigSchema","validateConfigSchema","enhancedSchema","implicitConfigSchema","registerModuleWithConfigSystem","registerModuleLoad","registerTranslationNamespace","namespace","translationOverridesSchema","defineExtensionConfigSchema","extensionName","provide","sourceName","whenStoreReady","store","ready","select","Promise","resolve","unsubscribe","resolved","update","getConfig","getTranslationOverrides","promises","processConfig","providedConfig","keyPathContext","validateStructure","setDefaults","runAllValidatorsInConfigTree","extensionConfigCache","slotModuleName","extensionModuleName","slotConfig","getExtensionNameFromId","extensionConfigSchema","cacheKey","JSON","nameOfSchemaSource","providedConfigs","getProvidedConfigs","sharedOverride","slotModuleConfig","mergeConfigsFor","configOverride","extensionConfig","combinedConfig","mergeConfigs","implementerToolsModuleCache","annotatedSchemas","getAllSchemasWithValuesAndSources","configsAndSources","c","moduleNames","Set","result","annotatedSchema","configSlices","sources","source","slice","i","merged","undefined","createValuesAndSourcesTree","schemaValuesAndSourcesCache","schemas","annotated","getSchemaWithValuesAndSources","isOrdinaryObject","obj","key","allConfigs","slotConfigPerModule","validateAllExtensionSlotConfigs","configureBlocks","configBySlotName","_configureBlocks","_slotName","blocks","configure","validateExtensionSlotConfig","keyPath","errorPrefix","invalidKeys","k","logError","n","updateMessage","thisKeyPath","schemaPart","elements","hasObjectSchema","valueType","inputConfig","allConfigsForModule","acc","value","validateBranchStructure","checkType","validateFreeformObjectStructure","validateArrayStructure","freeformObjectSchema","arraySchema","validatedAsArray","runValidators","_type","validators","returnValue","validatorResult","message","structuredClone","configPart","configWithDefaults","conf","objectKey","selectedConfigPart","elementsSchema","displayedValidationMessages","clearConfigErrors","resetConfigSystem","o","badKeys"],"mappings":"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"}\n//# sourceURL=webpack-internal:///../../framework/esm-config/dist/module-config/module-config.js\n\n}");
 
 },
 "../../framework/esm-config/dist/module-config/state.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
@@ -4696,7 +4696,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
 },
 "../../framework/esm-extensions/dist/extensions.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  attach: () => (attach),\n  detach: () => (detach),\n  detachAll: () => (detachAll),\n  getAssignedExtensions: () => (getAssignedExtensions),\n  getCandidateExtensions: () => (getCandidateExtensions),\n  getExtensionNameFromId: () => (getExtensionNameFromId),\n  getExtensionRegistration: () => (getExtensionRegistration),\n  getExtensionRegistrationFrom: () => (getExtensionRegistrationFrom),\n  registerExtension: () => (registerExtension),\n  registerExtensionSlot: () => (registerExtensionSlot),\n  reset: () => (reset)\n});\n/* import */ var _openmrs_esm_api__rspack_import_0 = __webpack_require__(\"../../framework/esm-api/dist/index.js\");\n/* import */ var _openmrs_esm_config__rspack_import_1 = __webpack_require__(\"../../framework/esm-config/dist/index.js\");\n/* import */ var _openmrs_esm_expression_evaluator__rspack_import_6 = __webpack_require__(\"../../framework/esm-expression-evaluator/dist/evaluator.js\");\n/* import */ var _openmrs_esm_feature_flags__rspack_import_2 = __webpack_require__(\"../../framework/esm-feature-flags/dist/index.js\");\n/* import */ var lodash_es__rspack_import_4 = __webpack_require__(\"../../../node_modules/lodash-es/isEqual.js\");\n/* import */ var lodash_es__rspack_import_5 = __webpack_require__(\"../../../node_modules/lodash-es/merge.js\");\n/* import */ var _store_js__rspack_import_3 = __webpack_require__(\"../../framework/esm-extensions/dist/store.js\");\n/** @module @category Extension */ /*\n * We have the following extension modes:\n *\n * - attached (set via code in form of: attach, detach, ...)\n * - configured (set via configuration in form of: added, removed, ...)\n * - assigned (computed from attached and configured)\n * - displayed (computed from assigned)\n */ \n\n\n\n\n\nconst extensionInternalStore = (0,_store_js__rspack_import_3.getExtensionInternalStore)();\nconst extensionStore = (0,_store_js__rspack_import_3.getExtensionStore)();\nconst slotsConfigStore = (0,_openmrs_esm_config__rspack_import_1.getExtensionSlotsConfigStore)();\nconst extensionsConfigStore = (0,_openmrs_esm_config__rspack_import_1.getExtensionsConfigStore)();\n/**\n * Slots whose derived state may have changed since the output store was last updated. `null`\n * stands for \"every slot\", and is used when an input changes that isn't scoped to one slot —\n * the session, a feature flag, connectivity, or a new extension registration.\n */ let dirtySlots = new Set();\nlet isRecomputingOutputStore = false;\nfunction markSlotsDirty(slots) {\n    if (slots === null) {\n        dirtySlots = null;\n    } else if (dirtySlots !== null) {\n        for (const slotName of slots){\n            dirtySlots.add(slotName);\n        }\n    }\n    (0,_store_js__rspack_import_3.scheduleRecomputation)(recomputeExtensionOutputStore);\n}\n/**\n * A subscriber that dirties a slot every time the output store is published would loop here for\n * ever, so the drain gives up after this many passes and leaves the rest for the next write. Any\n * real cascade settles in two or three.\n */ const maxRecomputationPasses = 20;\nfunction recomputeExtensionOutputStore() {\n    // Publishing notifies subscribers synchronously, so one that dirties a slot re-enters here. The\n    // loop below picks that work up; recursing instead would nest without bound.\n    if (isRecomputingOutputStore) {\n        return;\n    }\n    isRecomputingOutputStore = true;\n    try {\n        for(let pass = 1;; pass++){\n            const slots = dirtySlots;\n            if (slots !== null && slots.size === 0) {\n                return;\n            }\n            // Taken before the work so that anything dirtied while it runs accumulates for the next pass\n            // rather than being discarded when this one finishes.\n            dirtySlots = new Set();\n            try {\n                updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), _openmrs_esm_feature_flags__rspack_import_2.featureFlagsStore.getState(), _openmrs_esm_api__rspack_import_0.sessionStore.getState(), slots);\n            } catch (e) {\n                // Fold the work back in, so a failure leaves these slots marked for the next recomputation\n                // instead of stranding them stale.\n                dirtySlots = slots === null || dirtySlots === null ? null : new Set([\n                    ...slots,\n                    ...dirtySlots\n                ]);\n                throw e;\n            }\n            if (pass >= maxRecomputationPasses) {\n                console.error(`The extension system stopped recomputing after ${maxRecomputationPasses} passes because ` + `something keeps invalidating slots in response to the extension store being written. ` + `Some slots are left stale until the next write.`);\n                return;\n            }\n        }\n    } finally{\n        isRecomputingOutputStore = false;\n    }\n}\n/**\n * Re-derives the output store from the extension system's inputs.\n *\n * Two things keep this cheap. `dirtySlotNames` limits which slots are recomputed at all; passing\n * `null` recomputes every slot. And slots whose derived value hasn't changed keep their existing\n * object, so that components subscribed to one slot don't re-render because a different slot\n * changed.\n */ function updateExtensionOutputStore(internalState, extensionSlotConfigs, extensionsConfigState, featureFlagState, sessionState, dirtySlotNames = null) {\n    const previousSlots = extensionStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    const enabledFeatureFlags = Object.entries(featureFlagState.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);\n    for (let [slotName, slot] of Object.entries(internalState.slots)){\n        const previous = previousSlots[slotName];\n        if (previous && dirtySlotNames && !dirtySlotNames.has(slotName)) {\n            slots[slotName] = previous;\n            continue;\n        }\n        const { config } = (0,_openmrs_esm_config__rspack_import_1.getExtensionSlotConfigFromStore)(extensionSlotConfigs, slot.name);\n        const candidateExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigState, enabledFeatureFlags, sessionState.session);\n        if (previous && previous.moduleName === slot.moduleName && (0,lodash_es__rspack_import_4[\"default\"])(previous.candidateExtensions, candidateExtensions)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                moduleName: slot.moduleName,\n                candidateExtensions\n            };\n            changed = true;\n        }\n    }\n    if (changed || Object.keys(previousSlots).length !== Object.keys(slots).length) {\n        extensionStore.setState({\n            slots\n        });\n    }\n}\n/**\n * Returns the keys whose values differ between two records, including keys present in only one.\n */ function changedKeys(next, previous) {\n    const changed = new Set();\n    for (const key of Object.keys(next)){\n        if (next[key] !== previous[key]) {\n            changed.add(key);\n        }\n    }\n    for (const key of Object.keys(previous)){\n        if (!(key in next)) {\n            changed.add(key);\n        }\n    }\n    return changed;\n}\nextensionInternalStore.subscribe((state, previousState)=>{\n    // A new or changed registration can affect any slot the extension might be assigned to. Every\n    // other kind of change here — attaching, registering a slot — is scoped to the slots whose\n    // entries actually changed.\n    markSlotsDirty(state.extensions !== previousState.extensions ? null : changedKeys(state.slots, previousState.slots));\n});\n// Slot configs are per-slot, so a config change invalidates only the slots it names.\nslotsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.slots, previousState.slots));\n});\n// Extension configs are keyed by slot too, and the config system hands back the same per-slot\n// object when nothing under it changed, so only the slots whose configs actually moved are dirtied.\nextensionsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.configs, previousState.configs));\n});\n_openmrs_esm_feature_flags__rspack_import_2.featureFlagsStore.subscribe(()=>markSlotsDirty(null));\n_openmrs_esm_api__rspack_import_0.sessionStore.subscribe(()=>markSlotsDirty(null));\nfunction updateOutputStoreToCurrent() {\n    markSlotsDirty(null);\n}\nupdateOutputStoreToCurrent();\nfunction createNewExtensionSlotInfo(slotName, moduleName) {\n    return {\n        moduleName,\n        name: slotName,\n        attachedIds: []\n    };\n}\n/**\n * Given an extension ID, which is a string uniquely identifying\n * an instance of an extension within an extension slot, this\n * returns the extension name.\n *\n * @example\n * ```js\n * getExtensionNameFromId(\"foo#bar\")\n *  --> \"foo\"\n * getExtensionNameFromId(\"baz\")\n *  --> \"baz\"\n * ```\n */ function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\nfunction getExtensionRegistrationFrom(state, extensionId) {\n    const name = getExtensionNameFromId(extensionId);\n    return state.extensions[name];\n}\nfunction getExtensionRegistration(extensionId) {\n    const state = extensionInternalStore.getState();\n    return getExtensionRegistrationFrom(state, extensionId);\n}\n/**\n * Extensions must be registered in order to be rendered.\n * This is handled by the app shell, when extensions are provided\n * via the `routes.json` file and registered through `registerApp()`.\n * @internal\n */ const registerExtension = (extensionRegistration)=>(0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>({\n            ...state,\n            extensions: {\n                ...state.extensions,\n                [extensionRegistration.name]: {\n                    ...extensionRegistration\n                }\n            }\n        }));\n/**\n * Attach an extension to an extension slot.\n *\n * This will cause the extension to be rendered into the specified\n * extension slot, unless it is removed by configuration. Using\n * `attach` is an alternative to specifying the `slot` or `slots`\n * in the extension declaration.\n *\n * It is particularly useful when creating a slot into which\n * you want to render an existing extension. This enables you\n * to do so without modifying the extension's declaration, which\n * may be impractical or inappropriate, for example if you are\n * writing a module for a specific implementation.\n *\n * @param slotName a name uniquely identifying the slot\n * @param extensionId an extension name, with an optional #-suffix\n *    to distinguish it from other instances of the same extension\n *    attached to the same slot.\n */ function attach(slotName, extensionId) {\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>{\n        const existingSlot = state.slots[slotName];\n        if (!existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...createNewExtensionSlotInfo(slotName),\n                        attachedIds: [\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        } else {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...existingSlot,\n                        attachedIds: [\n                            ...existingSlot.attachedIds,\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        }\n    });\n}\n/**\n * Detaches an extension from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to detach from.\n * @param extensionId The ID of the extension to detach.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ function detach(extensionSlotName, extensionId) {\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot && existingSlot.attachedIds.includes(extensionId)) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: existingSlot.attachedIds.filter((id)=>id !== extensionId)\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/**\n * Detaches all extensions from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to clear.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ function detachAll(extensionSlotName) {\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: []\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/**\n * Get an order index for the extension. This will\n * come from either its configured order, its registered order\n * parameter, or the order in which it happened to be attached.\n *\n * The four bands below keep the comparison a total order: every extension lands in exactly one, and\n * those with no ordering information share the last band rather than taking a sentinel that can't be\n * compared against itself.\n */ function getOrder(extensionId, configuredOrder, registeredOrderIndex, attachedOrder) {\n    const configuredIndex = configuredOrder.indexOf(extensionId);\n    if (configuredIndex !== -1) {\n        return configuredIndex;\n    } else if (registeredOrderIndex !== undefined) {\n        // extensions that don't have a configured order should appear after those that do\n        return 1000 + registeredOrderIndex;\n    } else {\n        const assignedIndex = attachedOrder.indexOf(extensionId);\n        if (assignedIndex !== -1) {\n            // extensions that have neither a configured nor registered order should appear\n            // after all others\n            return 2000 + assignedIndex;\n        } else {\n            // Added by configuration with no order of any kind — after everything else, and among\n            // themselves in the order the configuration lists them.\n            return 3000;\n        }\n    }\n}\nfunction getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionConfigStoreState, enabledFeatureFlags, session) {\n    const attachedIds = internalState.slots[slotName].attachedIds;\n    const assignedIds = calculateAssignedIds(config, attachedIds);\n    const extensions = [];\n    for (let id of assignedIds){\n        const { config: rawExtensionConfig } = (0,_openmrs_esm_config__rspack_import_1.getExtensionConfigFromStore)(extensionConfigStoreState, slotName, id);\n        const rawExtensionSlotExtensionConfig = (0,_openmrs_esm_config__rspack_import_1.getExtensionConfigFromExtensionSlotStore)(config, slotName, id);\n        // `merge` mutates its first argument, and `rawExtensionConfig` belongs to the config store,\n        // so never merge into it.\n        const extensionConfig = rawExtensionSlotExtensionConfig ? (0,lodash_es__rspack_import_5[\"default\"])({}, rawExtensionConfig, rawExtensionSlotExtensionConfig) : rawExtensionConfig;\n        const name = getExtensionNameFromId(id);\n        const extension = internalState.extensions[name];\n        // if the extension has not been registered yet, do not include it\n        if (extension) {\n            const requiredPrivileges = extensionConfig?.['Display conditions']?.privileges ?? extension.privileges ?? [];\n            if (requiredPrivileges && (typeof requiredPrivileges === 'string' || Array.isArray(requiredPrivileges) && requiredPrivileges.length > 0)) {\n                if (!session?.user) {\n                    continue;\n                }\n                if (!(0,_openmrs_esm_api__rspack_import_0.userHasAccess)(requiredPrivileges, session.user)) {\n                    continue;\n                }\n            }\n            if (extension.featureFlag && !enabledFeatureFlags.includes(extension.featureFlag)) {\n                continue;\n            }\n            extensions.push({\n                id,\n                name,\n                moduleName: extension.moduleName,\n                config: extensionConfig,\n                featureFlag: extension.featureFlag,\n                meta: extension.meta,\n                displayConditionExpression: extensionConfig?.['Display conditions']?.expression || extension.displayExpression\n            });\n        }\n    }\n    return extensions;\n}\n/**\n * Narrows `extensions` to those whose display condition holds for one particular rendering of a\n * slot, evaluating each condition against `state`.\n *\n * An extension whose display condition throws is left out, on the grounds that a condition that cannot be\n * evaluated has not been met.\n *\n * @param extensions The extensions assigned to the slot, as the extension store holds them\n * @param state The state of this rendering of the slot\n * @param session The current session, which conditions may refer to as `session`\n * @param slotName The slot these were assigned to, used only to identify them if a condition throws\n * @returns Those of `extensions` that should be displayed, in the same order. Always a new array.\n */ function filterExtensionsByDisplayConditions(extensions, state, session = null, slotName) {\n    // Built once for the whole slot rather than per extension: the context is the same for all of\n    // them, and most slots have no conditions at all.\n    let expressionContext;\n    return extensions.filter((extension)=>{\n        const expression = extension.displayConditionExpression;\n        if (typeof expression !== 'string' || expression.trim().length === 0) {\n            return true;\n        }\n        expressionContext ?? (expressionContext = state && typeof state === 'object' ? {\n            session,\n            ...state\n        } : {\n            session\n        });\n        try {\n            return Boolean((0,_openmrs_esm_expression_evaluator__rspack_import_6.evaluateAsBoolean)(expression, expressionContext));\n        } catch (e) {\n            console.error(`Error while evaluating expression '${expression}' for ${extension.id}` + (slotName ? ` in ${slotName}` : ''), e);\n            return false;\n        }\n    });\n}\n/**\n * Gets the extensions a given rendering of a slot should display, in order. This is the supported\n * way to ask what belongs in a slot; reading the extension store directly skips display conditions.\n *\n * Display conditions are evaluated against `state`, so pass whatever the slot is being rendered\n * for. The same slot can be rendered many times with different state — once per row of a table,\n * say — and each rendering can resolve to a different set of extensions. Omitting `state` hides\n * every extension whose condition refers to it, since the condition cannot be evaluated.\n *\n * @param slotName The slot to load the extensions for\n * @param state The state of the rendering of the slot the extensions will be displayed in\n * @returns Those extensions assigned to the slot whose display conditions hold\n */ function getAssignedExtensions(slotName, state) {\n    return filterExtensionsByDisplayConditions(getCandidateExtensions(slotName), state, _openmrs_esm_api__rspack_import_0.sessionStore.getState().session, slotName);\n}\n/**\n * Gets everything assigned to a slot without evaluating any display condition, which\n * {@link getAssignedExtensions} cannot do without knowing the state of a particular rendering.\n *\n * This exists for tools that present a slot's configuration rather than render it — the UI editor\n * has to list an extension in order to let an implementer reorder or remove it, even where no\n * rendering would display it. Anything deciding what to render wants `getAssignedExtensions()`.\n *\n * @internal\n */ function getCandidateExtensions(slotName) {\n    return extensionStore.getState().slots[slotName]?.candidateExtensions ?? [];\n}\nfunction calculateAssignedIds(config, attachedIds) {\n    const addedIds = config.add || [];\n    const removedIds = config.remove || [];\n    const idOrder = config.order || [];\n    const { extensions } = extensionInternalStore.getState();\n    return [\n        ...attachedIds,\n        ...addedIds\n    ].filter((id)=>!removedIds.includes(id)).sort((idA, idB)=>{\n        const ai = getOrder(idA, idOrder, extensions[getExtensionNameFromId(idA)]?.order, attachedIds);\n        const bi = getOrder(idB, idOrder, extensions[getExtensionNameFromId(idB)]?.order, attachedIds);\n        // Ties keep their input order — `Array.prototype.sort` is stable, and the input is\n        // `[...attachedIds, ...addedIds]`, so two extensions the ordering rules can't separate\n        // come out in the order the code and the configuration declared them.\n        return ai - bi;\n    });\n}\n/**\n * Used by by extension slots at mount time.\n *\n * @param moduleName The name of the module that contains the extension slot\n * @param slotName The extension slot name that is actually used\n * @internal\n */ const registerExtensionSlot = (moduleName, slotName)=>extensionInternalStore.setState((currentState)=>{\n        const existingModuleName = currentState.slots[slotName]?.moduleName;\n        if (existingModuleName && existingModuleName != moduleName) {\n            console.warn(`An extension slot with the name '${slotName}' already exists. Refusing to register the same slot name twice (in \"registerExtensionSlot\"). The existing one is from module ${existingModuleName}.`);\n            return currentState;\n        }\n        if (existingModuleName && existingModuleName == moduleName) {\n            // Re-rendering an existing slot\n            return currentState;\n        }\n        if (currentState.slots[slotName]) {\n            return {\n                ...currentState,\n                slots: {\n                    ...currentState.slots,\n                    [slotName]: {\n                        ...currentState.slots[slotName],\n                        moduleName\n                    }\n                }\n            };\n        }\n        const slot = createNewExtensionSlotInfo(slotName, moduleName);\n        return {\n            ...currentState,\n            slots: {\n                ...currentState.slots,\n                [slotName]: {\n                    ...slot\n                }\n            }\n        };\n    });\n/**\n * @internal\n * Just for testing.\n */ const reset = ()=>{\n    // Invalidation is carried in module state, so it has to be reset too or it bleeds into the\n    // next test as either a stale dirty set or a missing one.\n    dirtySlots = null;\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)(()=>({\n            slots: {},\n            extensions: {}\n        }));\n    (0,_store_js__rspack_import_3.getExtensionRenderingsStore)().setState({\n        renderings: new Map()\n    });\n    extensionStore.setState({\n        slots: {}\n    });\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-extensions/dist/extensions.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-extensions/dist/extensions.js?85d8"],"sourcesContent":["/** @module @category Extension */ /*\n * We have the following extension modes:\n *\n * - attached (set via code in form of: attach, detach, ...)\n * - configured (set via configuration in form of: added, removed, ...)\n * - assigned (computed from attached and configured)\n * - displayed (computed from assigned)\n */ import { sessionStore, userHasAccess } from \"@openmrs/esm-api\";\nimport { getExtensionConfigFromExtensionSlotStore, getExtensionConfigFromStore, getExtensionSlotConfigFromStore, getExtensionSlotsConfigStore, getExtensionsConfigStore } from \"@openmrs/esm-config\";\nimport { evaluateAsBoolean } from \"@openmrs/esm-expression-evaluator\";\nimport { featureFlagsStore } from \"@openmrs/esm-feature-flags\";\nimport { isEqual, merge } from \"lodash-es\";\nimport { getExtensionRenderingsStore, getExtensionInternalStore, getExtensionStore, scheduleRecomputation, updateInternalExtensionStore } from \"./store.js\";\nconst extensionInternalStore = getExtensionInternalStore();\nconst extensionStore = getExtensionStore();\nconst slotsConfigStore = getExtensionSlotsConfigStore();\nconst extensionsConfigStore = getExtensionsConfigStore();\n/**\n * Slots whose derived state may have changed since the output store was last updated. `null`\n * stands for \"every slot\", and is used when an input changes that isn't scoped to one slot —\n * the session, a feature flag, connectivity, or a new extension registration.\n */ let dirtySlots = new Set();\nlet isRecomputingOutputStore = false;\nfunction markSlotsDirty(slots) {\n    if (slots === null) {\n        dirtySlots = null;\n    } else if (dirtySlots !== null) {\n        for (const slotName of slots){\n            dirtySlots.add(slotName);\n        }\n    }\n    scheduleRecomputation(recomputeExtensionOutputStore);\n}\n/**\n * A subscriber that dirties a slot every time the output store is published would loop here for\n * ever, so the drain gives up after this many passes and leaves the rest for the next write. Any\n * real cascade settles in two or three.\n */ const maxRecomputationPasses = 20;\nfunction recomputeExtensionOutputStore() {\n    // Publishing notifies subscribers synchronously, so one that dirties a slot re-enters here. The\n    // loop below picks that work up; recursing instead would nest without bound.\n    if (isRecomputingOutputStore) {\n        return;\n    }\n    isRecomputingOutputStore = true;\n    try {\n        for(let pass = 1;; pass++){\n            const slots = dirtySlots;\n            if (slots !== null && slots.size === 0) {\n                return;\n            }\n            // Taken before the work so that anything dirtied while it runs accumulates for the next pass\n            // rather than being discarded when this one finishes.\n            dirtySlots = new Set();\n            try {\n                updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState(), slots);\n            } catch (e) {\n                // Fold the work back in, so a failure leaves these slots marked for the next recomputation\n                // instead of stranding them stale.\n                dirtySlots = slots === null || dirtySlots === null ? null : new Set([\n                    ...slots,\n                    ...dirtySlots\n                ]);\n                throw e;\n            }\n            if (pass >= maxRecomputationPasses) {\n                console.error(`The extension system stopped recomputing after ${maxRecomputationPasses} passes because ` + `something keeps invalidating slots in response to the extension store being written. ` + `Some slots are left stale until the next write.`);\n                return;\n            }\n        }\n    } finally{\n        isRecomputingOutputStore = false;\n    }\n}\n/**\n * Re-derives the output store from the extension system's inputs.\n *\n * Two things keep this cheap. `dirtySlotNames` limits which slots are recomputed at all; passing\n * `null` recomputes every slot. And slots whose derived value hasn't changed keep their existing\n * object, so that components subscribed to one slot don't re-render because a different slot\n * changed.\n */ function updateExtensionOutputStore(internalState, extensionSlotConfigs, extensionsConfigState, featureFlagState, sessionState, dirtySlotNames = null) {\n    const previousSlots = extensionStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    const enabledFeatureFlags = Object.entries(featureFlagState.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);\n    for (let [slotName, slot] of Object.entries(internalState.slots)){\n        const previous = previousSlots[slotName];\n        if (previous && dirtySlotNames && !dirtySlotNames.has(slotName)) {\n            slots[slotName] = previous;\n            continue;\n        }\n        const { config } = getExtensionSlotConfigFromStore(extensionSlotConfigs, slot.name);\n        const candidateExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigState, enabledFeatureFlags, sessionState.session);\n        if (previous && previous.moduleName === slot.moduleName && isEqual(previous.candidateExtensions, candidateExtensions)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                moduleName: slot.moduleName,\n                candidateExtensions\n            };\n            changed = true;\n        }\n    }\n    if (changed || Object.keys(previousSlots).length !== Object.keys(slots).length) {\n        extensionStore.setState({\n            slots\n        });\n    }\n}\n/**\n * Returns the keys whose values differ between two records, including keys present in only one.\n */ function changedKeys(next, previous) {\n    const changed = new Set();\n    for (const key of Object.keys(next)){\n        if (next[key] !== previous[key]) {\n            changed.add(key);\n        }\n    }\n    for (const key of Object.keys(previous)){\n        if (!(key in next)) {\n            changed.add(key);\n        }\n    }\n    return changed;\n}\nextensionInternalStore.subscribe((state, previousState)=>{\n    // A new or changed registration can affect any slot the extension might be assigned to. Every\n    // other kind of change here — attaching, registering a slot — is scoped to the slots whose\n    // entries actually changed.\n    markSlotsDirty(state.extensions !== previousState.extensions ? null : changedKeys(state.slots, previousState.slots));\n});\n// Slot configs are per-slot, so a config change invalidates only the slots it names.\nslotsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.slots, previousState.slots));\n});\n// Extension configs are keyed by slot too, and the config system hands back the same per-slot\n// object when nothing under it changed, so only the slots whose configs actually moved are dirtied.\nextensionsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.configs, previousState.configs));\n});\nfeatureFlagsStore.subscribe(()=>markSlotsDirty(null));\nsessionStore.subscribe(()=>markSlotsDirty(null));\nfunction updateOutputStoreToCurrent() {\n    markSlotsDirty(null);\n}\nupdateOutputStoreToCurrent();\nfunction createNewExtensionSlotInfo(slotName, moduleName) {\n    return {\n        moduleName,\n        name: slotName,\n        attachedIds: []\n    };\n}\n/**\n * Given an extension ID, which is a string uniquely identifying\n * an instance of an extension within an extension slot, this\n * returns the extension name.\n *\n * @example\n * ```js\n * getExtensionNameFromId(\"foo#bar\")\n *  --> \"foo\"\n * getExtensionNameFromId(\"baz\")\n *  --> \"baz\"\n * ```\n */ export function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\nexport function getExtensionRegistrationFrom(state, extensionId) {\n    const name = getExtensionNameFromId(extensionId);\n    return state.extensions[name];\n}\nexport function getExtensionRegistration(extensionId) {\n    const state = extensionInternalStore.getState();\n    return getExtensionRegistrationFrom(state, extensionId);\n}\n/**\n * Extensions must be registered in order to be rendered.\n * This is handled by the app shell, when extensions are provided\n * via the `routes.json` file and registered through `registerApp()`.\n * @internal\n */ export const registerExtension = (extensionRegistration)=>updateInternalExtensionStore((state)=>({\n            ...state,\n            extensions: {\n                ...state.extensions,\n                [extensionRegistration.name]: {\n                    ...extensionRegistration\n                }\n            }\n        }));\n/**\n * Attach an extension to an extension slot.\n *\n * This will cause the extension to be rendered into the specified\n * extension slot, unless it is removed by configuration. Using\n * `attach` is an alternative to specifying the `slot` or `slots`\n * in the extension declaration.\n *\n * It is particularly useful when creating a slot into which\n * you want to render an existing extension. This enables you\n * to do so without modifying the extension's declaration, which\n * may be impractical or inappropriate, for example if you are\n * writing a module for a specific implementation.\n *\n * @param slotName a name uniquely identifying the slot\n * @param extensionId an extension name, with an optional #-suffix\n *    to distinguish it from other instances of the same extension\n *    attached to the same slot.\n */ export function attach(slotName, extensionId) {\n    updateInternalExtensionStore((state)=>{\n        const existingSlot = state.slots[slotName];\n        if (!existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...createNewExtensionSlotInfo(slotName),\n                        attachedIds: [\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        } else {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...existingSlot,\n                        attachedIds: [\n                            ...existingSlot.attachedIds,\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        }\n    });\n}\n/**\n * Detaches an extension from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to detach from.\n * @param extensionId The ID of the extension to detach.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ export function detach(extensionSlotName, extensionId) {\n    updateInternalExtensionStore((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot && existingSlot.attachedIds.includes(extensionId)) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: existingSlot.attachedIds.filter((id)=>id !== extensionId)\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/**\n * Detaches all extensions from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to clear.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ export function detachAll(extensionSlotName) {\n    updateInternalExtensionStore((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: []\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/**\n * Get an order index for the extension. This will\n * come from either its configured order, its registered order\n * parameter, or the order in which it happened to be attached.\n *\n * The four bands below keep the comparison a total order: every extension lands in exactly one, and\n * those with no ordering information share the last band rather than taking a sentinel that can't be\n * compared against itself.\n */ function getOrder(extensionId, configuredOrder, registeredOrderIndex, attachedOrder) {\n    const configuredIndex = configuredOrder.indexOf(extensionId);\n    if (configuredIndex !== -1) {\n        return configuredIndex;\n    } else if (registeredOrderIndex !== undefined) {\n        // extensions that don't have a configured order should appear after those that do\n        return 1000 + registeredOrderIndex;\n    } else {\n        const assignedIndex = attachedOrder.indexOf(extensionId);\n        if (assignedIndex !== -1) {\n            // extensions that have neither a configured nor registered order should appear\n            // after all others\n            return 2000 + assignedIndex;\n        } else {\n            // Added by configuration with no order of any kind — after everything else, and among\n            // themselves in the order the configuration lists them.\n            return 3000;\n        }\n    }\n}\nfunction getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionConfigStoreState, enabledFeatureFlags, session) {\n    const attachedIds = internalState.slots[slotName].attachedIds;\n    const assignedIds = calculateAssignedIds(config, attachedIds);\n    const extensions = [];\n    for (let id of assignedIds){\n        const { config: rawExtensionConfig } = getExtensionConfigFromStore(extensionConfigStoreState, slotName, id);\n        const rawExtensionSlotExtensionConfig = getExtensionConfigFromExtensionSlotStore(config, slotName, id);\n        // `merge` mutates its first argument, and `rawExtensionConfig` belongs to the config store,\n        // so never merge into it.\n        const extensionConfig = rawExtensionSlotExtensionConfig ? merge({}, rawExtensionConfig, rawExtensionSlotExtensionConfig) : rawExtensionConfig;\n        const name = getExtensionNameFromId(id);\n        const extension = internalState.extensions[name];\n        // if the extension has not been registered yet, do not include it\n        if (extension) {\n            const requiredPrivileges = extensionConfig?.['Display conditions']?.privileges ?? extension.privileges ?? [];\n            if (requiredPrivileges && (typeof requiredPrivileges === 'string' || Array.isArray(requiredPrivileges) && requiredPrivileges.length > 0)) {\n                if (!session?.user) {\n                    continue;\n                }\n                if (!userHasAccess(requiredPrivileges, session.user)) {\n                    continue;\n                }\n            }\n            if (extension.featureFlag && !enabledFeatureFlags.includes(extension.featureFlag)) {\n                continue;\n            }\n            extensions.push({\n                id,\n                name,\n                moduleName: extension.moduleName,\n                config: extensionConfig,\n                featureFlag: extension.featureFlag,\n                meta: extension.meta,\n                displayConditionExpression: extensionConfig?.['Display conditions']?.expression || extension.displayExpression\n            });\n        }\n    }\n    return extensions;\n}\n/**\n * Narrows `extensions` to those whose display condition holds for one particular rendering of a\n * slot, evaluating each condition against `state`.\n *\n * An extension whose display condition throws is left out, on the grounds that a condition that cannot be\n * evaluated has not been met.\n *\n * @param extensions The extensions assigned to the slot, as the extension store holds them\n * @param state The state of this rendering of the slot\n * @param session The current session, which conditions may refer to as `session`\n * @param slotName The slot these were assigned to, used only to identify them if a condition throws\n * @returns Those of `extensions` that should be displayed, in the same order. Always a new array.\n */ function filterExtensionsByDisplayConditions(extensions, state, session = null, slotName) {\n    // Built once for the whole slot rather than per extension: the context is the same for all of\n    // them, and most slots have no conditions at all.\n    let expressionContext;\n    return extensions.filter((extension)=>{\n        const expression = extension.displayConditionExpression;\n        if (typeof expression !== 'string' || expression.trim().length === 0) {\n            return true;\n        }\n        expressionContext ?? (expressionContext = state && typeof state === 'object' ? {\n            session,\n            ...state\n        } : {\n            session\n        });\n        try {\n            return Boolean(evaluateAsBoolean(expression, expressionContext));\n        } catch (e) {\n            console.error(`Error while evaluating expression '${expression}' for ${extension.id}` + (slotName ? ` in ${slotName}` : ''), e);\n            return false;\n        }\n    });\n}\n/**\n * Gets the extensions a given rendering of a slot should display, in order. This is the supported\n * way to ask what belongs in a slot; reading the extension store directly skips display conditions.\n *\n * Display conditions are evaluated against `state`, so pass whatever the slot is being rendered\n * for. The same slot can be rendered many times with different state — once per row of a table,\n * say — and each rendering can resolve to a different set of extensions. Omitting `state` hides\n * every extension whose condition refers to it, since the condition cannot be evaluated.\n *\n * @param slotName The slot to load the extensions for\n * @param state The state of the rendering of the slot the extensions will be displayed in\n * @returns Those extensions assigned to the slot whose display conditions hold\n */ export function getAssignedExtensions(slotName, state) {\n    return filterExtensionsByDisplayConditions(getCandidateExtensions(slotName), state, sessionStore.getState().session, slotName);\n}\n/**\n * Gets everything assigned to a slot without evaluating any display condition, which\n * {@link getAssignedExtensions} cannot do without knowing the state of a particular rendering.\n *\n * This exists for tools that present a slot's configuration rather than render it — the UI editor\n * has to list an extension in order to let an implementer reorder or remove it, even where no\n * rendering would display it. Anything deciding what to render wants `getAssignedExtensions()`.\n *\n * @internal\n */ export function getCandidateExtensions(slotName) {\n    return extensionStore.getState().slots[slotName]?.candidateExtensions ?? [];\n}\nfunction calculateAssignedIds(config, attachedIds) {\n    const addedIds = config.add || [];\n    const removedIds = config.remove || [];\n    const idOrder = config.order || [];\n    const { extensions } = extensionInternalStore.getState();\n    return [\n        ...attachedIds,\n        ...addedIds\n    ].filter((id)=>!removedIds.includes(id)).sort((idA, idB)=>{\n        const ai = getOrder(idA, idOrder, extensions[getExtensionNameFromId(idA)]?.order, attachedIds);\n        const bi = getOrder(idB, idOrder, extensions[getExtensionNameFromId(idB)]?.order, attachedIds);\n        // Ties keep their input order — `Array.prototype.sort` is stable, and the input is\n        // `[...attachedIds, ...addedIds]`, so two extensions the ordering rules can't separate\n        // come out in the order the code and the configuration declared them.\n        return ai - bi;\n    });\n}\n/**\n * Used by by extension slots at mount time.\n *\n * @param moduleName The name of the module that contains the extension slot\n * @param slotName The extension slot name that is actually used\n * @internal\n */ export const registerExtensionSlot = (moduleName, slotName)=>extensionInternalStore.setState((currentState)=>{\n        const existingModuleName = currentState.slots[slotName]?.moduleName;\n        if (existingModuleName && existingModuleName != moduleName) {\n            console.warn(`An extension slot with the name '${slotName}' already exists. Refusing to register the same slot name twice (in \"registerExtensionSlot\"). The existing one is from module ${existingModuleName}.`);\n            return currentState;\n        }\n        if (existingModuleName && existingModuleName == moduleName) {\n            // Re-rendering an existing slot\n            return currentState;\n        }\n        if (currentState.slots[slotName]) {\n            return {\n                ...currentState,\n                slots: {\n                    ...currentState.slots,\n                    [slotName]: {\n                        ...currentState.slots[slotName],\n                        moduleName\n                    }\n                }\n            };\n        }\n        const slot = createNewExtensionSlotInfo(slotName, moduleName);\n        return {\n            ...currentState,\n            slots: {\n                ...currentState.slots,\n                [slotName]: {\n                    ...slot\n                }\n            }\n        };\n    });\n/**\n * @internal\n * Just for testing.\n */ export const reset = ()=>{\n    // Invalidation is carried in module state, so it has to be reset too or it bleeds into the\n    // next test as either a stale dirty set or a missing one.\n    dirtySlots = null;\n    updateInternalExtensionStore(()=>({\n            slots: {},\n            extensions: {}\n        }));\n    getExtensionRenderingsStore().setState({\n        renderings: new Map()\n    });\n    extensionStore.setState({\n        slots: {}\n    });\n};\n"],"names":["sessionStore","userHasAccess","getExtensionConfigFromExtensionSlotStore","getExtensionConfigFromStore","getExtensionSlotConfigFromStore","getExtensionSlotsConfigStore","getExtensionsConfigStore","evaluateAsBoolean","featureFlagsStore","isEqual","merge","getExtensionRenderingsStore","getExtensionInternalStore","getExtensionStore","scheduleRecomputation","updateInternalExtensionStore","extensionInternalStore","extensionStore","slotsConfigStore","extensionsConfigStore","dirtySlots","Set","isRecomputingOutputStore","markSlotsDirty","slots","slotName","recomputeExtensionOutputStore","maxRecomputationPasses","pass","updateExtensionOutputStore","e","console","internalState","extensionSlotConfigs","extensionsConfigState","featureFlagState","sessionState","dirtySlotNames","previousSlots","changed","enabledFeatureFlags","Object","enabled","name","slot","previous","config","candidateExtensions","getAssignedExtensionsFromSlotData","changedKeys","next","key","state","previousState","updateOutputStoreToCurrent","createNewExtensionSlotInfo","moduleName","getExtensionNameFromId","extensionId","extensionName","getExtensionRegistrationFrom","getExtensionRegistration","registerExtension","extensionRegistration","attach","existingSlot","detach","extensionSlotName","id","detachAll","getOrder","configuredOrder","registeredOrderIndex","attachedOrder","configuredIndex","undefined","assignedIndex","extensionConfigStoreState","session","attachedIds","assignedIds","calculateAssignedIds","extensions","rawExtensionConfig","rawExtensionSlotExtensionConfig","extensionConfig","extension","requiredPrivileges","Array","filterExtensionsByDisplayConditions","expressionContext","expression","Boolean","getAssignedExtensions","getCandidateExtensions","addedIds","removedIds","idOrder","idA","idB","ai","bi","registerExtensionSlot","currentState","existingModuleName","reset","Map"],"mappings":"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"}\n//# sourceURL=webpack-internal:///../../framework/esm-extensions/dist/extensions.js\n\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  attach: () => (attach),\n  detach: () => (detach),\n  detachAll: () => (detachAll),\n  getAssignedExtensions: () => (getAssignedExtensions),\n  getCandidateExtensions: () => (getCandidateExtensions),\n  getExtensionNameFromId: () => (getExtensionNameFromId),\n  getExtensionRegistration: () => (getExtensionRegistration),\n  getExtensionRegistrationFrom: () => (getExtensionRegistrationFrom),\n  registerExtension: () => (registerExtension),\n  registerExtensionSlot: () => (registerExtensionSlot),\n  reset: () => (reset)\n});\n/* import */ var _openmrs_esm_api__rspack_import_0 = __webpack_require__(\"../../framework/esm-api/dist/index.js\");\n/* import */ var _openmrs_esm_config__rspack_import_1 = __webpack_require__(\"../../framework/esm-config/dist/index.js\");\n/* import */ var _openmrs_esm_expression_evaluator__rspack_import_6 = __webpack_require__(\"../../framework/esm-expression-evaluator/dist/evaluator.js\");\n/* import */ var _openmrs_esm_feature_flags__rspack_import_2 = __webpack_require__(\"../../framework/esm-feature-flags/dist/index.js\");\n/* import */ var lodash_es__rspack_import_4 = __webpack_require__(\"../../../node_modules/lodash-es/isEqual.js\");\n/* import */ var lodash_es__rspack_import_5 = __webpack_require__(\"../../../node_modules/lodash-es/merge.js\");\n/* import */ var _store_js__rspack_import_3 = __webpack_require__(\"../../framework/esm-extensions/dist/store.js\");\n/** @module @category Extension */ /*\n * We have the following extension modes:\n *\n * - attached (set via code in form of: attach, detach, ...)\n * - configured (set via configuration in form of: added, removed, ...)\n * - assigned (computed from attached and configured)\n * - displayed (computed from assigned)\n */ \n\n\n\n\n\nconst extensionInternalStore = (0,_store_js__rspack_import_3.getExtensionInternalStore)();\nconst extensionStore = (0,_store_js__rspack_import_3.getExtensionStore)();\nconst slotsConfigStore = (0,_openmrs_esm_config__rspack_import_1.getExtensionSlotsConfigStore)();\nconst extensionsConfigStore = (0,_openmrs_esm_config__rspack_import_1.getExtensionsConfigStore)();\n/**\n * Slots whose derived state may have changed since the output store was last updated. `null`\n * stands for \"every slot\", and is used when an input changes that isn't scoped to one slot —\n * the session, a feature flag, connectivity, or a new extension registration.\n */ let dirtySlots = new Set();\nlet isRecomputingOutputStore = false;\nfunction markSlotsDirty(slots) {\n    if (slots === null) {\n        dirtySlots = null;\n    } else if (dirtySlots !== null) {\n        for (const slotName of slots){\n            dirtySlots.add(slotName);\n        }\n    }\n    (0,_store_js__rspack_import_3.scheduleRecomputation)(recomputeExtensionOutputStore);\n}\n/**\n * A subscriber that dirties a slot every time the output store is published would loop here for\n * ever, so the drain gives up after this many passes and leaves the rest for the next write. Any\n * real cascade settles in two or three.\n */ const maxRecomputationPasses = 20;\nfunction recomputeExtensionOutputStore() {\n    // Publishing notifies subscribers synchronously, so one that dirties a slot re-enters here. The\n    // loop below picks that work up; recursing instead would nest without bound.\n    if (isRecomputingOutputStore) {\n        return;\n    }\n    isRecomputingOutputStore = true;\n    try {\n        for(let pass = 1;; pass++){\n            const slots = dirtySlots;\n            if (slots !== null && slots.size === 0) {\n                return;\n            }\n            // Taken before the work so that anything dirtied while it runs accumulates for the next pass\n            // rather than being discarded when this one finishes.\n            dirtySlots = new Set();\n            try {\n                updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), _openmrs_esm_feature_flags__rspack_import_2.featureFlagsStore.getState(), _openmrs_esm_api__rspack_import_0.sessionStore.getState(), slots);\n            } catch (e) {\n                // Fold the work back in, so a failure leaves these slots marked for the next recomputation\n                // instead of stranding them stale.\n                dirtySlots = slots === null || dirtySlots === null ? null : new Set([\n                    ...slots,\n                    ...dirtySlots\n                ]);\n                throw e;\n            }\n            if (pass >= maxRecomputationPasses) {\n                console.error(`The extension system stopped recomputing after ${maxRecomputationPasses} passes because ` + `something keeps invalidating slots in response to the extension store being written. ` + `Some slots are left stale until the next write.`);\n                return;\n            }\n        }\n    } finally{\n        isRecomputingOutputStore = false;\n    }\n}\n/**\n * Re-derives the output store from the extension system's inputs.\n *\n * Two things keep this cheap. `dirtySlotNames` limits which slots are recomputed at all; passing\n * `null` recomputes every slot. And slots whose derived value hasn't changed keep their existing\n * object, so that components subscribed to one slot don't re-render because a different slot\n * changed.\n */ function updateExtensionOutputStore(internalState, extensionSlotConfigs, extensionsConfigState, featureFlagState, sessionState, dirtySlotNames = null) {\n    const previousSlots = extensionStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    const enabledFeatureFlags = Object.entries(featureFlagState.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);\n    for (let [slotName, slot] of Object.entries(internalState.slots)){\n        const previous = previousSlots[slotName];\n        if (previous && dirtySlotNames && !dirtySlotNames.has(slotName)) {\n            slots[slotName] = previous;\n            continue;\n        }\n        const { config } = (0,_openmrs_esm_config__rspack_import_1.getExtensionSlotConfigFromStore)(extensionSlotConfigs, slot.name);\n        const candidateExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigState, enabledFeatureFlags, sessionState.session);\n        if (previous && previous.moduleName === slot.moduleName && (0,lodash_es__rspack_import_4[\"default\"])(previous.candidateExtensions, candidateExtensions)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                moduleName: slot.moduleName,\n                candidateExtensions\n            };\n            changed = true;\n        }\n    }\n    if (changed || Object.keys(previousSlots).length !== Object.keys(slots).length) {\n        extensionStore.setState({\n            slots\n        });\n    }\n}\n/**\n * Returns the keys whose values differ between two records, including keys present in only one.\n */ function changedKeys(next, previous) {\n    const changed = new Set();\n    for (const key of Object.keys(next)){\n        if (next[key] !== previous[key]) {\n            changed.add(key);\n        }\n    }\n    for (const key of Object.keys(previous)){\n        if (!(key in next)) {\n            changed.add(key);\n        }\n    }\n    return changed;\n}\nextensionInternalStore.subscribe((state, previousState)=>{\n    // A new or changed registration can affect any slot the extension might be assigned to. Every\n    // other kind of change here — attaching, registering a slot — is scoped to the slots whose\n    // entries actually changed.\n    markSlotsDirty(state.extensions !== previousState.extensions ? null : changedKeys(state.slots, previousState.slots));\n});\n// Slot configs are per-slot, so a config change invalidates only the slots it names.\nslotsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.slots, previousState.slots));\n});\n// Extension configs are keyed by slot too, and the config system hands back the same per-slot\n// object when nothing under it changed, so only the slots whose configs actually moved are dirtied.\nextensionsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.configs, previousState.configs));\n});\n_openmrs_esm_feature_flags__rspack_import_2.featureFlagsStore.subscribe(()=>markSlotsDirty(null));\n_openmrs_esm_api__rspack_import_0.sessionStore.subscribe(()=>markSlotsDirty(null));\nfunction updateOutputStoreToCurrent() {\n    markSlotsDirty(null);\n}\nupdateOutputStoreToCurrent();\nfunction createNewExtensionSlotInfo(slotName, moduleName) {\n    return {\n        moduleName,\n        name: slotName,\n        attachedIds: []\n    };\n}\n/**\n * Given an extension ID, which is a string uniquely identifying\n * an instance of an extension within an extension slot, this\n * returns the extension name.\n *\n * @example\n * ```js\n * getExtensionNameFromId(\"foo#bar\")\n *  --> \"foo\"\n * getExtensionNameFromId(\"baz\")\n *  --> \"baz\"\n * ```\n */ function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\nfunction getExtensionRegistrationFrom(state, extensionId) {\n    const name = getExtensionNameFromId(extensionId);\n    return state.extensions[name];\n}\nfunction getExtensionRegistration(extensionId) {\n    const state = extensionInternalStore.getState();\n    return getExtensionRegistrationFrom(state, extensionId);\n}\n/**\n * Extensions must be registered in order to be rendered.\n * This is handled by the app shell, when extensions are provided\n * via the `routes.json` file and registered through `registerApp()`.\n * @internal\n */ const registerExtension = (extensionRegistration)=>(0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>({\n            ...state,\n            extensions: {\n                ...state.extensions,\n                [extensionRegistration.name]: {\n                    ...extensionRegistration\n                }\n            }\n        }));\n/**\n * Attach an extension to an extension slot.\n *\n * This will cause the extension to be rendered into the specified\n * extension slot, unless it is removed by configuration. Using\n * `attach` is an alternative to specifying the `slot` or `slots`\n * in the extension declaration.\n *\n * It is particularly useful when creating a slot into which\n * you want to render an existing extension. This enables you\n * to do so without modifying the extension's declaration, which\n * may be impractical or inappropriate, for example if you are\n * writing a module for a specific implementation.\n *\n * @param slotName a name uniquely identifying the slot\n * @param extensionId an extension name, with an optional #-suffix\n *    to distinguish it from other instances of the same extension\n *    attached to the same slot.\n */ function attach(slotName, extensionId) {\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>{\n        const existingSlot = state.slots[slotName];\n        if (!existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...createNewExtensionSlotInfo(slotName),\n                        attachedIds: [\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        } else {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...existingSlot,\n                        attachedIds: [\n                            ...existingSlot.attachedIds,\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        }\n    });\n}\n/**\n * Detaches an extension from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to detach from.\n * @param extensionId The ID of the extension to detach.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ function detach(extensionSlotName, extensionId) {\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot && existingSlot.attachedIds.includes(extensionId)) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: existingSlot.attachedIds.filter((id)=>id !== extensionId)\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/**\n * Detaches all extensions from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to clear.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ function detachAll(extensionSlotName) {\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: []\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/** Maps each ID to the index of its first occurrence, matching `Array.prototype.indexOf`. */ function indexById(ids) {\n    const index = new Map();\n    ids.forEach((id, i)=>{\n        if (!index.has(id)) {\n            index.set(id, i);\n        }\n    });\n    return index;\n}\n/**\n * Get an order index for the extension. This will\n * come from either its configured order, its registered order\n * parameter, or the order in which it happened to be attached.\n *\n * The four bands below keep the comparison a total order: every extension lands in exactly one, and\n * those with no ordering information share the last band rather than taking a sentinel that can't be\n * compared against itself.\n */ function getOrder(extensionId, configuredOrder, registeredOrderIndex, attachedOrder) {\n    const configuredIndex = configuredOrder.get(extensionId);\n    if (configuredIndex !== undefined) {\n        return configuredIndex;\n    } else if (registeredOrderIndex !== undefined) {\n        // extensions that don't have a configured order should appear after those that do\n        return 1000 + registeredOrderIndex;\n    } else {\n        const assignedIndex = attachedOrder.get(extensionId);\n        if (assignedIndex !== undefined) {\n            // extensions that have neither a configured nor registered order should appear\n            // after all others\n            return 2000 + assignedIndex;\n        } else {\n            // Added by configuration with no order of any kind — after everything else, and among\n            // themselves in the order the configuration lists them.\n            return 3000;\n        }\n    }\n}\nfunction getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionConfigStoreState, enabledFeatureFlags, session) {\n    const attachedIds = internalState.slots[slotName].attachedIds;\n    const assignedIds = calculateAssignedIds(config, attachedIds);\n    const extensions = [];\n    for (let id of assignedIds){\n        const { config: rawExtensionConfig } = (0,_openmrs_esm_config__rspack_import_1.getExtensionConfigFromStore)(extensionConfigStoreState, slotName, id);\n        const rawExtensionSlotExtensionConfig = (0,_openmrs_esm_config__rspack_import_1.getExtensionConfigFromExtensionSlotStore)(config, slotName, id);\n        // `merge` mutates its first argument, and `rawExtensionConfig` belongs to the config store,\n        // so never merge into it.\n        const extensionConfig = rawExtensionSlotExtensionConfig ? (0,lodash_es__rspack_import_5[\"default\"])({}, rawExtensionConfig, rawExtensionSlotExtensionConfig) : rawExtensionConfig;\n        const name = getExtensionNameFromId(id);\n        const extension = internalState.extensions[name];\n        // if the extension has not been registered yet, do not include it\n        if (extension) {\n            const requiredPrivileges = extensionConfig?.['Display conditions']?.privileges ?? extension.privileges ?? [];\n            if (requiredPrivileges && (typeof requiredPrivileges === 'string' || Array.isArray(requiredPrivileges) && requiredPrivileges.length > 0)) {\n                if (!session?.user) {\n                    continue;\n                }\n                if (!(0,_openmrs_esm_api__rspack_import_0.userHasAccess)(requiredPrivileges, session.user)) {\n                    continue;\n                }\n            }\n            if (extension.featureFlag && !enabledFeatureFlags.includes(extension.featureFlag)) {\n                continue;\n            }\n            extensions.push({\n                id,\n                name,\n                moduleName: extension.moduleName,\n                config: extensionConfig,\n                featureFlag: extension.featureFlag,\n                meta: extension.meta,\n                displayConditionExpression: extensionConfig?.['Display conditions']?.expression || extension.displayExpression\n            });\n        }\n    }\n    return extensions;\n}\n/**\n * Narrows `extensions` to those whose display condition holds for one particular rendering of a\n * slot, evaluating each condition against `state`.\n *\n * An extension whose display condition throws is left out, on the grounds that a condition that cannot be\n * evaluated has not been met.\n *\n * @param extensions The extensions assigned to the slot, as the extension store holds them\n * @param state The state of this rendering of the slot\n * @param session The current session, which conditions may refer to as `session`\n * @param slotName The slot these were assigned to, used only to identify them if a condition throws\n * @returns Those of `extensions` that should be displayed, in the same order. Always a new array.\n */ function filterExtensionsByDisplayConditions(extensions, state, session = null, slotName) {\n    // Built once for the whole slot rather than per extension: the context is the same for all of\n    // them, and most slots have no conditions at all.\n    let expressionContext;\n    return extensions.filter((extension)=>{\n        const expression = extension.displayConditionExpression;\n        if (typeof expression !== 'string' || expression.trim().length === 0) {\n            return true;\n        }\n        expressionContext ?? (expressionContext = state && typeof state === 'object' ? {\n            session,\n            ...state\n        } : {\n            session\n        });\n        try {\n            return Boolean((0,_openmrs_esm_expression_evaluator__rspack_import_6.evaluateAsBoolean)(expression, expressionContext));\n        } catch (e) {\n            console.error(`Error while evaluating expression '${expression}' for ${extension.id}` + (slotName ? ` in ${slotName}` : ''), e);\n            return false;\n        }\n    });\n}\n/**\n * Gets the extensions a given rendering of a slot should display, in order. This is the supported\n * way to ask what belongs in a slot; reading the extension store directly skips display conditions.\n *\n * Display conditions are evaluated against `state`, so pass whatever the slot is being rendered\n * for. The same slot can be rendered many times with different state — once per row of a table,\n * say — and each rendering can resolve to a different set of extensions. Omitting `state` hides\n * every extension whose condition refers to it, since the condition cannot be evaluated.\n *\n * @param slotName The slot to load the extensions for\n * @param state The state of the rendering of the slot the extensions will be displayed in\n * @returns Those extensions assigned to the slot whose display conditions hold\n */ function getAssignedExtensions(slotName, state) {\n    return filterExtensionsByDisplayConditions(getCandidateExtensions(slotName), state, _openmrs_esm_api__rspack_import_0.sessionStore.getState().session, slotName);\n}\n/**\n * Gets everything assigned to a slot without evaluating any display condition, which\n * {@link getAssignedExtensions} cannot do without knowing the state of a particular rendering.\n *\n * This exists for tools that present a slot's configuration rather than render it — the UI editor\n * has to list an extension in order to let an implementer reorder or remove it, even where no\n * rendering would display it. Anything deciding what to render wants `getAssignedExtensions()`.\n *\n * @internal\n */ function getCandidateExtensions(slotName) {\n    return extensionStore.getState().slots[slotName]?.candidateExtensions ?? [];\n}\nfunction calculateAssignedIds(config, attachedIds) {\n    const addedIds = config.add || [];\n    const removedIds = config.remove || [];\n    const idOrder = config.order || [];\n    const { extensions } = extensionInternalStore.getState();\n    const removed = new Set(removedIds);\n    const ids = [\n        ...attachedIds,\n        ...addedIds\n    ].filter((id)=>!removed.has(id));\n    const configuredIndex = indexById(idOrder);\n    const attachedIndex = indexById(attachedIds);\n    // Computed once per ID: calling `getOrder` from the comparator makes the sort quadratic.\n    const order = new Map(ids.map((id)=>[\n            id,\n            getOrder(id, configuredIndex, extensions[getExtensionNameFromId(id)]?.order, attachedIndex)\n        ]));\n    // Ties keep their input order — `Array.prototype.sort` is stable, and the input is\n    // `[...attachedIds, ...addedIds]`, so two extensions the ordering rules can't separate\n    // come out in the order the code and the configuration declared them.\n    return ids.sort((idA, idB)=>order.get(idA) - order.get(idB));\n}\n/**\n * Used by by extension slots at mount time.\n *\n * @param moduleName The name of the module that contains the extension slot\n * @param slotName The extension slot name that is actually used\n * @internal\n */ const registerExtensionSlot = (moduleName, slotName)=>extensionInternalStore.setState((currentState)=>{\n        const existingModuleName = currentState.slots[slotName]?.moduleName;\n        if (existingModuleName && existingModuleName != moduleName) {\n            console.warn(`An extension slot with the name '${slotName}' already exists. Refusing to register the same slot name twice (in \"registerExtensionSlot\"). The existing one is from module ${existingModuleName}.`);\n            return currentState;\n        }\n        if (existingModuleName && existingModuleName == moduleName) {\n            // Re-rendering an existing slot\n            return currentState;\n        }\n        if (currentState.slots[slotName]) {\n            return {\n                ...currentState,\n                slots: {\n                    ...currentState.slots,\n                    [slotName]: {\n                        ...currentState.slots[slotName],\n                        moduleName\n                    }\n                }\n            };\n        }\n        const slot = createNewExtensionSlotInfo(slotName, moduleName);\n        return {\n            ...currentState,\n            slots: {\n                ...currentState.slots,\n                [slotName]: {\n                    ...slot\n                }\n            }\n        };\n    });\n/**\n * @internal\n * Just for testing.\n */ const reset = ()=>{\n    // Invalidation is carried in module state, so it has to be reset too or it bleeds into the\n    // next test as either a stale dirty set or a missing one.\n    dirtySlots = null;\n    (0,_store_js__rspack_import_3.updateInternalExtensionStore)(()=>({\n            slots: {},\n            extensions: {}\n        }));\n    (0,_store_js__rspack_import_3.getExtensionRenderingsStore)().setState({\n        renderings: new Map()\n    });\n    extensionStore.setState({\n        slots: {}\n    });\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-extensions/dist/extensions.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-extensions/dist/extensions.js?85d8"],"sourcesContent":["/** @module @category Extension */ /*\n * We have the following extension modes:\n *\n * - attached (set via code in form of: attach, detach, ...)\n * - configured (set via configuration in form of: added, removed, ...)\n * - assigned (computed from attached and configured)\n * - displayed (computed from assigned)\n */ import { sessionStore, userHasAccess } from \"@openmrs/esm-api\";\nimport { getExtensionConfigFromExtensionSlotStore, getExtensionConfigFromStore, getExtensionSlotConfigFromStore, getExtensionSlotsConfigStore, getExtensionsConfigStore } from \"@openmrs/esm-config\";\nimport { evaluateAsBoolean } from \"@openmrs/esm-expression-evaluator\";\nimport { featureFlagsStore } from \"@openmrs/esm-feature-flags\";\nimport { isEqual, merge } from \"lodash-es\";\nimport { getExtensionRenderingsStore, getExtensionInternalStore, getExtensionStore, scheduleRecomputation, updateInternalExtensionStore } from \"./store.js\";\nconst extensionInternalStore = getExtensionInternalStore();\nconst extensionStore = getExtensionStore();\nconst slotsConfigStore = getExtensionSlotsConfigStore();\nconst extensionsConfigStore = getExtensionsConfigStore();\n/**\n * Slots whose derived state may have changed since the output store was last updated. `null`\n * stands for \"every slot\", and is used when an input changes that isn't scoped to one slot —\n * the session, a feature flag, connectivity, or a new extension registration.\n */ let dirtySlots = new Set();\nlet isRecomputingOutputStore = false;\nfunction markSlotsDirty(slots) {\n    if (slots === null) {\n        dirtySlots = null;\n    } else if (dirtySlots !== null) {\n        for (const slotName of slots){\n            dirtySlots.add(slotName);\n        }\n    }\n    scheduleRecomputation(recomputeExtensionOutputStore);\n}\n/**\n * A subscriber that dirties a slot every time the output store is published would loop here for\n * ever, so the drain gives up after this many passes and leaves the rest for the next write. Any\n * real cascade settles in two or three.\n */ const maxRecomputationPasses = 20;\nfunction recomputeExtensionOutputStore() {\n    // Publishing notifies subscribers synchronously, so one that dirties a slot re-enters here. The\n    // loop below picks that work up; recursing instead would nest without bound.\n    if (isRecomputingOutputStore) {\n        return;\n    }\n    isRecomputingOutputStore = true;\n    try {\n        for(let pass = 1;; pass++){\n            const slots = dirtySlots;\n            if (slots !== null && slots.size === 0) {\n                return;\n            }\n            // Taken before the work so that anything dirtied while it runs accumulates for the next pass\n            // rather than being discarded when this one finishes.\n            dirtySlots = new Set();\n            try {\n                updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState(), slots);\n            } catch (e) {\n                // Fold the work back in, so a failure leaves these slots marked for the next recomputation\n                // instead of stranding them stale.\n                dirtySlots = slots === null || dirtySlots === null ? null : new Set([\n                    ...slots,\n                    ...dirtySlots\n                ]);\n                throw e;\n            }\n            if (pass >= maxRecomputationPasses) {\n                console.error(`The extension system stopped recomputing after ${maxRecomputationPasses} passes because ` + `something keeps invalidating slots in response to the extension store being written. ` + `Some slots are left stale until the next write.`);\n                return;\n            }\n        }\n    } finally{\n        isRecomputingOutputStore = false;\n    }\n}\n/**\n * Re-derives the output store from the extension system's inputs.\n *\n * Two things keep this cheap. `dirtySlotNames` limits which slots are recomputed at all; passing\n * `null` recomputes every slot. And slots whose derived value hasn't changed keep their existing\n * object, so that components subscribed to one slot don't re-render because a different slot\n * changed.\n */ function updateExtensionOutputStore(internalState, extensionSlotConfigs, extensionsConfigState, featureFlagState, sessionState, dirtySlotNames = null) {\n    const previousSlots = extensionStore.getState().slots;\n    const slots = {};\n    let changed = false;\n    const enabledFeatureFlags = Object.entries(featureFlagState.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);\n    for (let [slotName, slot] of Object.entries(internalState.slots)){\n        const previous = previousSlots[slotName];\n        if (previous && dirtySlotNames && !dirtySlotNames.has(slotName)) {\n            slots[slotName] = previous;\n            continue;\n        }\n        const { config } = getExtensionSlotConfigFromStore(extensionSlotConfigs, slot.name);\n        const candidateExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigState, enabledFeatureFlags, sessionState.session);\n        if (previous && previous.moduleName === slot.moduleName && isEqual(previous.candidateExtensions, candidateExtensions)) {\n            slots[slotName] = previous;\n        } else {\n            slots[slotName] = {\n                moduleName: slot.moduleName,\n                candidateExtensions\n            };\n            changed = true;\n        }\n    }\n    if (changed || Object.keys(previousSlots).length !== Object.keys(slots).length) {\n        extensionStore.setState({\n            slots\n        });\n    }\n}\n/**\n * Returns the keys whose values differ between two records, including keys present in only one.\n */ function changedKeys(next, previous) {\n    const changed = new Set();\n    for (const key of Object.keys(next)){\n        if (next[key] !== previous[key]) {\n            changed.add(key);\n        }\n    }\n    for (const key of Object.keys(previous)){\n        if (!(key in next)) {\n            changed.add(key);\n        }\n    }\n    return changed;\n}\nextensionInternalStore.subscribe((state, previousState)=>{\n    // A new or changed registration can affect any slot the extension might be assigned to. Every\n    // other kind of change here — attaching, registering a slot — is scoped to the slots whose\n    // entries actually changed.\n    markSlotsDirty(state.extensions !== previousState.extensions ? null : changedKeys(state.slots, previousState.slots));\n});\n// Slot configs are per-slot, so a config change invalidates only the slots it names.\nslotsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.slots, previousState.slots));\n});\n// Extension configs are keyed by slot too, and the config system hands back the same per-slot\n// object when nothing under it changed, so only the slots whose configs actually moved are dirtied.\nextensionsConfigStore.subscribe((state, previousState)=>{\n    markSlotsDirty(changedKeys(state.configs, previousState.configs));\n});\nfeatureFlagsStore.subscribe(()=>markSlotsDirty(null));\nsessionStore.subscribe(()=>markSlotsDirty(null));\nfunction updateOutputStoreToCurrent() {\n    markSlotsDirty(null);\n}\nupdateOutputStoreToCurrent();\nfunction createNewExtensionSlotInfo(slotName, moduleName) {\n    return {\n        moduleName,\n        name: slotName,\n        attachedIds: []\n    };\n}\n/**\n * Given an extension ID, which is a string uniquely identifying\n * an instance of an extension within an extension slot, this\n * returns the extension name.\n *\n * @example\n * ```js\n * getExtensionNameFromId(\"foo#bar\")\n *  --> \"foo\"\n * getExtensionNameFromId(\"baz\")\n *  --> \"baz\"\n * ```\n */ export function getExtensionNameFromId(extensionId) {\n    const [extensionName] = extensionId.split('#');\n    return extensionName;\n}\nexport function getExtensionRegistrationFrom(state, extensionId) {\n    const name = getExtensionNameFromId(extensionId);\n    return state.extensions[name];\n}\nexport function getExtensionRegistration(extensionId) {\n    const state = extensionInternalStore.getState();\n    return getExtensionRegistrationFrom(state, extensionId);\n}\n/**\n * Extensions must be registered in order to be rendered.\n * This is handled by the app shell, when extensions are provided\n * via the `routes.json` file and registered through `registerApp()`.\n * @internal\n */ export const registerExtension = (extensionRegistration)=>updateInternalExtensionStore((state)=>({\n            ...state,\n            extensions: {\n                ...state.extensions,\n                [extensionRegistration.name]: {\n                    ...extensionRegistration\n                }\n            }\n        }));\n/**\n * Attach an extension to an extension slot.\n *\n * This will cause the extension to be rendered into the specified\n * extension slot, unless it is removed by configuration. Using\n * `attach` is an alternative to specifying the `slot` or `slots`\n * in the extension declaration.\n *\n * It is particularly useful when creating a slot into which\n * you want to render an existing extension. This enables you\n * to do so without modifying the extension's declaration, which\n * may be impractical or inappropriate, for example if you are\n * writing a module for a specific implementation.\n *\n * @param slotName a name uniquely identifying the slot\n * @param extensionId an extension name, with an optional #-suffix\n *    to distinguish it from other instances of the same extension\n *    attached to the same slot.\n */ export function attach(slotName, extensionId) {\n    updateInternalExtensionStore((state)=>{\n        const existingSlot = state.slots[slotName];\n        if (!existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...createNewExtensionSlotInfo(slotName),\n                        attachedIds: [\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        } else {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [slotName]: {\n                        ...existingSlot,\n                        attachedIds: [\n                            ...existingSlot.attachedIds,\n                            extensionId\n                        ]\n                    }\n                }\n            };\n        }\n    });\n}\n/**\n * Detaches an extension from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to detach from.\n * @param extensionId The ID of the extension to detach.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ export function detach(extensionSlotName, extensionId) {\n    updateInternalExtensionStore((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot && existingSlot.attachedIds.includes(extensionId)) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: existingSlot.attachedIds.filter((id)=>id !== extensionId)\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/**\n * Detaches all extensions from an extension slot.\n *\n * @param extensionSlotName The name of the extension slot to clear.\n *\n * @deprecated Avoid using this. Extension attachments should be considered declarative.\n */ export function detachAll(extensionSlotName) {\n    updateInternalExtensionStore((state)=>{\n        const existingSlot = state.slots[extensionSlotName];\n        if (existingSlot) {\n            return {\n                ...state,\n                slots: {\n                    ...state.slots,\n                    [extensionSlotName]: {\n                        ...existingSlot,\n                        attachedIds: []\n                    }\n                }\n            };\n        } else {\n            return state;\n        }\n    });\n}\n/** Maps each ID to the index of its first occurrence, matching `Array.prototype.indexOf`. */ function indexById(ids) {\n    const index = new Map();\n    ids.forEach((id, i)=>{\n        if (!index.has(id)) {\n            index.set(id, i);\n        }\n    });\n    return index;\n}\n/**\n * Get an order index for the extension. This will\n * come from either its configured order, its registered order\n * parameter, or the order in which it happened to be attached.\n *\n * The four bands below keep the comparison a total order: every extension lands in exactly one, and\n * those with no ordering information share the last band rather than taking a sentinel that can't be\n * compared against itself.\n */ function getOrder(extensionId, configuredOrder, registeredOrderIndex, attachedOrder) {\n    const configuredIndex = configuredOrder.get(extensionId);\n    if (configuredIndex !== undefined) {\n        return configuredIndex;\n    } else if (registeredOrderIndex !== undefined) {\n        // extensions that don't have a configured order should appear after those that do\n        return 1000 + registeredOrderIndex;\n    } else {\n        const assignedIndex = attachedOrder.get(extensionId);\n        if (assignedIndex !== undefined) {\n            // extensions that have neither a configured nor registered order should appear\n            // after all others\n            return 2000 + assignedIndex;\n        } else {\n            // Added by configuration with no order of any kind — after everything else, and among\n            // themselves in the order the configuration lists them.\n            return 3000;\n        }\n    }\n}\nfunction getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionConfigStoreState, enabledFeatureFlags, session) {\n    const attachedIds = internalState.slots[slotName].attachedIds;\n    const assignedIds = calculateAssignedIds(config, attachedIds);\n    const extensions = [];\n    for (let id of assignedIds){\n        const { config: rawExtensionConfig } = getExtensionConfigFromStore(extensionConfigStoreState, slotName, id);\n        const rawExtensionSlotExtensionConfig = getExtensionConfigFromExtensionSlotStore(config, slotName, id);\n        // `merge` mutates its first argument, and `rawExtensionConfig` belongs to the config store,\n        // so never merge into it.\n        const extensionConfig = rawExtensionSlotExtensionConfig ? merge({}, rawExtensionConfig, rawExtensionSlotExtensionConfig) : rawExtensionConfig;\n        const name = getExtensionNameFromId(id);\n        const extension = internalState.extensions[name];\n        // if the extension has not been registered yet, do not include it\n        if (extension) {\n            const requiredPrivileges = extensionConfig?.['Display conditions']?.privileges ?? extension.privileges ?? [];\n            if (requiredPrivileges && (typeof requiredPrivileges === 'string' || Array.isArray(requiredPrivileges) && requiredPrivileges.length > 0)) {\n                if (!session?.user) {\n                    continue;\n                }\n                if (!userHasAccess(requiredPrivileges, session.user)) {\n                    continue;\n                }\n            }\n            if (extension.featureFlag && !enabledFeatureFlags.includes(extension.featureFlag)) {\n                continue;\n            }\n            extensions.push({\n                id,\n                name,\n                moduleName: extension.moduleName,\n                config: extensionConfig,\n                featureFlag: extension.featureFlag,\n                meta: extension.meta,\n                displayConditionExpression: extensionConfig?.['Display conditions']?.expression || extension.displayExpression\n            });\n        }\n    }\n    return extensions;\n}\n/**\n * Narrows `extensions` to those whose display condition holds for one particular rendering of a\n * slot, evaluating each condition against `state`.\n *\n * An extension whose display condition throws is left out, on the grounds that a condition that cannot be\n * evaluated has not been met.\n *\n * @param extensions The extensions assigned to the slot, as the extension store holds them\n * @param state The state of this rendering of the slot\n * @param session The current session, which conditions may refer to as `session`\n * @param slotName The slot these were assigned to, used only to identify them if a condition throws\n * @returns Those of `extensions` that should be displayed, in the same order. Always a new array.\n */ function filterExtensionsByDisplayConditions(extensions, state, session = null, slotName) {\n    // Built once for the whole slot rather than per extension: the context is the same for all of\n    // them, and most slots have no conditions at all.\n    let expressionContext;\n    return extensions.filter((extension)=>{\n        const expression = extension.displayConditionExpression;\n        if (typeof expression !== 'string' || expression.trim().length === 0) {\n            return true;\n        }\n        expressionContext ?? (expressionContext = state && typeof state === 'object' ? {\n            session,\n            ...state\n        } : {\n            session\n        });\n        try {\n            return Boolean(evaluateAsBoolean(expression, expressionContext));\n        } catch (e) {\n            console.error(`Error while evaluating expression '${expression}' for ${extension.id}` + (slotName ? ` in ${slotName}` : ''), e);\n            return false;\n        }\n    });\n}\n/**\n * Gets the extensions a given rendering of a slot should display, in order. This is the supported\n * way to ask what belongs in a slot; reading the extension store directly skips display conditions.\n *\n * Display conditions are evaluated against `state`, so pass whatever the slot is being rendered\n * for. The same slot can be rendered many times with different state — once per row of a table,\n * say — and each rendering can resolve to a different set of extensions. Omitting `state` hides\n * every extension whose condition refers to it, since the condition cannot be evaluated.\n *\n * @param slotName The slot to load the extensions for\n * @param state The state of the rendering of the slot the extensions will be displayed in\n * @returns Those extensions assigned to the slot whose display conditions hold\n */ export function getAssignedExtensions(slotName, state) {\n    return filterExtensionsByDisplayConditions(getCandidateExtensions(slotName), state, sessionStore.getState().session, slotName);\n}\n/**\n * Gets everything assigned to a slot without evaluating any display condition, which\n * {@link getAssignedExtensions} cannot do without knowing the state of a particular rendering.\n *\n * This exists for tools that present a slot's configuration rather than render it — the UI editor\n * has to list an extension in order to let an implementer reorder or remove it, even where no\n * rendering would display it. Anything deciding what to render wants `getAssignedExtensions()`.\n *\n * @internal\n */ export function getCandidateExtensions(slotName) {\n    return extensionStore.getState().slots[slotName]?.candidateExtensions ?? [];\n}\nfunction calculateAssignedIds(config, attachedIds) {\n    const addedIds = config.add || [];\n    const removedIds = config.remove || [];\n    const idOrder = config.order || [];\n    const { extensions } = extensionInternalStore.getState();\n    const removed = new Set(removedIds);\n    const ids = [\n        ...attachedIds,\n        ...addedIds\n    ].filter((id)=>!removed.has(id));\n    const configuredIndex = indexById(idOrder);\n    const attachedIndex = indexById(attachedIds);\n    // Computed once per ID: calling `getOrder` from the comparator makes the sort quadratic.\n    const order = new Map(ids.map((id)=>[\n            id,\n            getOrder(id, configuredIndex, extensions[getExtensionNameFromId(id)]?.order, attachedIndex)\n        ]));\n    // Ties keep their input order — `Array.prototype.sort` is stable, and the input is\n    // `[...attachedIds, ...addedIds]`, so two extensions the ordering rules can't separate\n    // come out in the order the code and the configuration declared them.\n    return ids.sort((idA, idB)=>order.get(idA) - order.get(idB));\n}\n/**\n * Used by by extension slots at mount time.\n *\n * @param moduleName The name of the module that contains the extension slot\n * @param slotName The extension slot name that is actually used\n * @internal\n */ export const registerExtensionSlot = (moduleName, slotName)=>extensionInternalStore.setState((currentState)=>{\n        const existingModuleName = currentState.slots[slotName]?.moduleName;\n        if (existingModuleName && existingModuleName != moduleName) {\n            console.warn(`An extension slot with the name '${slotName}' already exists. Refusing to register the same slot name twice (in \"registerExtensionSlot\"). The existing one is from module ${existingModuleName}.`);\n            return currentState;\n        }\n        if (existingModuleName && existingModuleName == moduleName) {\n            // Re-rendering an existing slot\n            return currentState;\n        }\n        if (currentState.slots[slotName]) {\n            return {\n                ...currentState,\n                slots: {\n                    ...currentState.slots,\n                    [slotName]: {\n                        ...currentState.slots[slotName],\n                        moduleName\n                    }\n                }\n            };\n        }\n        const slot = createNewExtensionSlotInfo(slotName, moduleName);\n        return {\n            ...currentState,\n            slots: {\n                ...currentState.slots,\n                [slotName]: {\n                    ...slot\n                }\n            }\n        };\n    });\n/**\n * @internal\n * Just for testing.\n */ export const reset = ()=>{\n    // Invalidation is carried in module state, so it has to be reset too or it bleeds into the\n    // next test as either a stale dirty set or a missing one.\n    dirtySlots = null;\n    updateInternalExtensionStore(()=>({\n            slots: {},\n            extensions: {}\n        }));\n    getExtensionRenderingsStore().setState({\n        renderings: new Map()\n    });\n    extensionStore.setState({\n        slots: {}\n    });\n};\n"],"names":["sessionStore","userHasAccess","getExtensionConfigFromExtensionSlotStore","getExtensionConfigFromStore","getExtensionSlotConfigFromStore","getExtensionSlotsConfigStore","getExtensionsConfigStore","evaluateAsBoolean","featureFlagsStore","isEqual","merge","getExtensionRenderingsStore","getExtensionInternalStore","getExtensionStore","scheduleRecomputation","updateInternalExtensionStore","extensionInternalStore","extensionStore","slotsConfigStore","extensionsConfigStore","dirtySlots","Set","isRecomputingOutputStore","markSlotsDirty","slots","slotName","recomputeExtensionOutputStore","maxRecomputationPasses","pass","updateExtensionOutputStore","e","console","internalState","extensionSlotConfigs","extensionsConfigState","featureFlagState","sessionState","dirtySlotNames","previousSlots","changed","enabledFeatureFlags","Object","enabled","name","slot","previous","config","candidateExtensions","getAssignedExtensionsFromSlotData","changedKeys","next","key","state","previousState","updateOutputStoreToCurrent","createNewExtensionSlotInfo","moduleName","getExtensionNameFromId","extensionId","extensionName","getExtensionRegistrationFrom","getExtensionRegistration","registerExtension","extensionRegistration","attach","existingSlot","detach","extensionSlotName","id","detachAll","indexById","ids","index","Map","i","getOrder","configuredOrder","registeredOrderIndex","attachedOrder","configuredIndex","undefined","assignedIndex","extensionConfigStoreState","session","attachedIds","assignedIds","calculateAssignedIds","extensions","rawExtensionConfig","rawExtensionSlotExtensionConfig","extensionConfig","extension","requiredPrivileges","Array","filterExtensionsByDisplayConditions","expressionContext","expression","Boolean","getAssignedExtensions","getCandidateExtensions","addedIds","removedIds","idOrder","removed","attachedIndex","order","idA","idB","registerExtensionSlot","currentState","existingModuleName","reset"],"mappings":"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"}\n//# sourceURL=webpack-internal:///../../framework/esm-extensions/dist/extensions.js\n\n}");
 
 },
 "../../framework/esm-extensions/dist/index.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
@@ -5126,7 +5126,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webp
 },
 "../../framework/esm-translations/dist/translations.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";
-eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  coreTranslations: () => (coreTranslations)\n});\n/** Please keep these alphabetized */ const addressFields = {\n    address1: 'Address line 1',\n    address2: 'Address line 2',\n    address3: 'Address line 3',\n    address4: 'Address line 4',\n    address5: 'Address line 5',\n    address6: 'Address line 6',\n    city: 'City',\n    cityVillage: 'City',\n    country: 'Country',\n    countyDistrict: 'District',\n    district: 'District',\n    postalCode: 'Postal code',\n    state: 'State',\n    stateProvince: 'State'\n};\nconst workspaceTranslations = {\n    closeAllOpenedWorkspaces: 'Discard changes in {{count}} workspaces',\n    closingAllWorkspacesPromptBody: 'There may be unsaved changes in the following workspaces. Do you want to discard changes in the following workspaces? {{workspaceNames}}',\n    closingAllWorkspacesPromptTitle: 'You have unsaved changes',\n    discard: 'Discard',\n    hide: 'Hide',\n    maximize: 'Maximize',\n    minimize: 'Minimize',\n    openAnyway: 'Open anyway',\n    unsavedChangesInOpenedWorkspace: 'You may have unsaved changes in the opened workspace. Do you want to discard these changes?',\n    unsavedChangesInWorkspace: 'There may be unsaved changes in \"{{workspaceName}}\". Please save them before opening another workspace.',\n    unsavedChangesTitleText: 'Unsaved changes',\n    workspaceHeader: 'Workspace header'\n};\nconst workspace2Translations = {\n    discardUnsavedChangesPromptBodyMultiple: '{{count}} workspaces have unsaved changes. Closing them will discard the changes:',\n    discardUnsavedChangesPromptBodySingle: '<strong>{{workspaceTitle}}</strong> has unsaved changes. Closing it will discard them.',\n    discardUnsavedChangesPromptTitle: 'Discard unsaved changes?',\n    keepEditing: 'Keep editing'\n};\nconst coreTranslations = {\n    ...addressFields,\n    ...workspaceTranslations,\n    ...workspace2Translations,\n    abnormalValue: 'Abnormal value',\n    actions: 'Actions',\n    actionableNotification: 'Actionable notification',\n    address: 'Address',\n    age: 'Age',\n    batchActionItemSelected: '{{totalSelected}} item selected',\n    batchActionsItemsSelected: '{{totalSelected}} items selected',\n    cancel: 'Cancel',\n    change: 'Change',\n    // Default value for the implementationName config property\n    Clinic: 'Clinic',\n    close: 'Close',\n    closesActionableNotification: 'Close actionable notification',\n    closeSnackbar: 'Close snackbar',\n    confirm: 'Confirm',\n    contactAdministratorIfIssuePersists: 'Contact your system administrator if the problem persists.',\n    contactDetails: 'Contact details',\n    delete: 'Delete',\n    discardChanges: 'Discard changes',\n    edit: 'Edit',\n    emptyStateText: 'There are no {{displayText}} to display',\n    error: 'Error',\n    errorCopy: 'Sorry, there was a problem displaying this information. You can try to reload this page, or contact the site administrator and quote the error code above.',\n    errorLoadingLoginLocations: 'Unable to load login locations. Please try again or contact support if the problem persists.',\n    female: 'Female',\n    leftNavigation: 'Left navigation',\n    loading: 'Loading',\n    localVersion: 'Local Build',\n    male: 'Male',\n    navigateNonHttp: 'Could not navigate to the requested page as it is not a safe URL',\n    noResultsToDisplay: 'No results to display',\n    notAvailable: 'Not available',\n    other: 'Other',\n    paginationItemsCount: '{{pageItemsCount}} / {{totalItems}} items',\n    paginationOfPages: 'of {{count}} pages',\n    patientAvatarAlt: 'Avatar for {{patientName}}',\n    patientIdentifierSticker: 'Patient identifier sticker',\n    patientLists: 'Patient lists',\n    patientPhotoAlt: 'Profile photo of {{patientName}}',\n    patientPhotoPlaceholder: 'Photo placeholder for {{patientName}}',\n    prereleaseVersion: 'Prerelease',\n    print: 'Print',\n    printError: 'Print error',\n    printErrorExplainer: 'An error occurred in {{errorLocation}}',\n    printIdentifierSticker: 'Print identifier sticker',\n    printing: 'Printing',\n    recordNewEntry: 'Record {{displayText}}',\n    relationships: 'Relationships',\n    resetOverrides: 'Reset overrides',\n    save: 'Save',\n    scriptLoadingFailed: 'Error: Script failed to load',\n    scriptLoadingError: 'Failed to load overridden script from {{url}}. Please check that the bundled script is available at the expected URL. Click the button below to reset all import map overrides.',\n    searchForLocation: 'Search for a location',\n    seeAll: 'See all',\n    seeMoreLists: 'See {{count}} more lists',\n    selectAll: 'Select all',\n    sex: 'Sex',\n    showLess: 'Show less',\n    showMore: 'Show more',\n    snackbarNotification: 'Snackbar notification',\n    toggleDevTools: 'Toggle dev tools',\n    unknown: 'Unknown',\n    yearAbbreviation: 'yr',\n    yearsAbbreviation: 'yrs'\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-translations/dist/translations.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-translations/dist/translations.js?90df"],"sourcesContent":["/** Please keep these alphabetized */ const addressFields = {\n    address1: 'Address line 1',\n    address2: 'Address line 2',\n    address3: 'Address line 3',\n    address4: 'Address line 4',\n    address5: 'Address line 5',\n    address6: 'Address line 6',\n    city: 'City',\n    cityVillage: 'City',\n    country: 'Country',\n    countyDistrict: 'District',\n    district: 'District',\n    postalCode: 'Postal code',\n    state: 'State',\n    stateProvince: 'State'\n};\nconst workspaceTranslations = {\n    closeAllOpenedWorkspaces: 'Discard changes in {{count}} workspaces',\n    closingAllWorkspacesPromptBody: 'There may be unsaved changes in the following workspaces. Do you want to discard changes in the following workspaces? {{workspaceNames}}',\n    closingAllWorkspacesPromptTitle: 'You have unsaved changes',\n    discard: 'Discard',\n    hide: 'Hide',\n    maximize: 'Maximize',\n    minimize: 'Minimize',\n    openAnyway: 'Open anyway',\n    unsavedChangesInOpenedWorkspace: 'You may have unsaved changes in the opened workspace. Do you want to discard these changes?',\n    unsavedChangesInWorkspace: 'There may be unsaved changes in \"{{workspaceName}}\". Please save them before opening another workspace.',\n    unsavedChangesTitleText: 'Unsaved changes',\n    workspaceHeader: 'Workspace header'\n};\nconst workspace2Translations = {\n    discardUnsavedChangesPromptBodyMultiple: '{{count}} workspaces have unsaved changes. Closing them will discard the changes:',\n    discardUnsavedChangesPromptBodySingle: '<strong>{{workspaceTitle}}</strong> has unsaved changes. Closing it will discard them.',\n    discardUnsavedChangesPromptTitle: 'Discard unsaved changes?',\n    keepEditing: 'Keep editing'\n};\nexport const coreTranslations = {\n    ...addressFields,\n    ...workspaceTranslations,\n    ...workspace2Translations,\n    abnormalValue: 'Abnormal value',\n    actions: 'Actions',\n    actionableNotification: 'Actionable notification',\n    address: 'Address',\n    age: 'Age',\n    batchActionItemSelected: '{{totalSelected}} item selected',\n    batchActionsItemsSelected: '{{totalSelected}} items selected',\n    cancel: 'Cancel',\n    change: 'Change',\n    // Default value for the implementationName config property\n    Clinic: 'Clinic',\n    close: 'Close',\n    closesActionableNotification: 'Close actionable notification',\n    closeSnackbar: 'Close snackbar',\n    confirm: 'Confirm',\n    contactAdministratorIfIssuePersists: 'Contact your system administrator if the problem persists.',\n    contactDetails: 'Contact details',\n    delete: 'Delete',\n    discardChanges: 'Discard changes',\n    edit: 'Edit',\n    emptyStateText: 'There are no {{displayText}} to display',\n    error: 'Error',\n    errorCopy: 'Sorry, there was a problem displaying this information. You can try to reload this page, or contact the site administrator and quote the error code above.',\n    errorLoadingLoginLocations: 'Unable to load login locations. Please try again or contact support if the problem persists.',\n    female: 'Female',\n    leftNavigation: 'Left navigation',\n    loading: 'Loading',\n    localVersion: 'Local Build',\n    male: 'Male',\n    navigateNonHttp: 'Could not navigate to the requested page as it is not a safe URL',\n    noResultsToDisplay: 'No results to display',\n    notAvailable: 'Not available',\n    other: 'Other',\n    paginationItemsCount: '{{pageItemsCount}} / {{totalItems}} items',\n    paginationOfPages: 'of {{count}} pages',\n    patientAvatarAlt: 'Avatar for {{patientName}}',\n    patientIdentifierSticker: 'Patient identifier sticker',\n    patientLists: 'Patient lists',\n    patientPhotoAlt: 'Profile photo of {{patientName}}',\n    patientPhotoPlaceholder: 'Photo placeholder for {{patientName}}',\n    prereleaseVersion: 'Prerelease',\n    print: 'Print',\n    printError: 'Print error',\n    printErrorExplainer: 'An error occurred in {{errorLocation}}',\n    printIdentifierSticker: 'Print identifier sticker',\n    printing: 'Printing',\n    recordNewEntry: 'Record {{displayText}}',\n    relationships: 'Relationships',\n    resetOverrides: 'Reset overrides',\n    save: 'Save',\n    scriptLoadingFailed: 'Error: Script failed to load',\n    scriptLoadingError: 'Failed to load overridden script from {{url}}. Please check that the bundled script is available at the expected URL. Click the button below to reset all import map overrides.',\n    searchForLocation: 'Search for a location',\n    seeAll: 'See all',\n    seeMoreLists: 'See {{count}} more lists',\n    selectAll: 'Select all',\n    sex: 'Sex',\n    showLess: 'Show less',\n    showMore: 'Show more',\n    snackbarNotification: 'Snackbar notification',\n    toggleDevTools: 'Toggle dev tools',\n    unknown: 'Unknown',\n    yearAbbreviation: 'yr',\n    yearsAbbreviation: 'yrs'\n};\n"],"names":["addressFields","workspaceTranslations","workspace2Translations","coreTranslations"],"mappings":";;;;AAAA,mCAAmC,GAAG,MAAMA,gBAAgB;IACxD,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,MAAM;IACN,aAAa;IACb,SAAS;IACT,gBAAgB;IAChB,UAAU;IACV,YAAY;IACZ,OAAO;IACP,eAAe;AACnB;AACA,MAAMC,wBAAwB;IAC1B,0BAA0B;IAC1B,gCAAgC;IAChC,iCAAiC;IACjC,SAAS;IACT,MAAM;IACN,UAAU;IACV,UAAU;IACV,YAAY;IACZ,iCAAiC;IACjC,2BAA2B;IAC3B,yBAAyB;IACzB,iBAAiB;AACrB;AACA,MAAMC,yBAAyB;IAC3B,yCAAyC;IACzC,uCAAuC;IACvC,kCAAkC;IAClC,aAAa;AACjB;AACO,MAAMC,mBAAmB;IAC5B,GAAGH,aAAa;IAChB,GAAGC,qBAAqB;IACxB,GAAGC,sBAAsB;IACzB,eAAe;IACf,SAAS;IACT,wBAAwB;IACxB,SAAS;IACT,KAAK;IACL,yBAAyB;IACzB,2BAA2B;IAC3B,QAAQ;IACR,QAAQ;IACR,2DAA2D;IAC3D,QAAQ;IACR,OAAO;IACP,8BAA8B;IAC9B,eAAe;IACf,SAAS;IACT,qCAAqC;IACrC,gBAAgB;IAChB,QAAQ;IACR,gBAAgB;IAChB,MAAM;IACN,gBAAgB;IAChB,OAAO;IACP,WAAW;IACX,4BAA4B;IAC5B,QAAQ;IACR,gBAAgB;IAChB,SAAS;IACT,cAAc;IACd,MAAM;IACN,iBAAiB;IACjB,oBAAoB;IACpB,cAAc;IACd,OAAO;IACP,sBAAsB;IACtB,mBAAmB;IACnB,kBAAkB;IAClB,0BAA0B;IAC1B,cAAc;IACd,iBAAiB;IACjB,yBAAyB;IACzB,mBAAmB;IACnB,OAAO;IACP,YAAY;IACZ,qBAAqB;IACrB,wBAAwB;IACxB,UAAU;IACV,gBAAgB;IAChB,eAAe;IACf,gBAAgB;IAChB,MAAM;IACN,qBAAqB;IACrB,oBAAoB;IACpB,mBAAmB;IACnB,QAAQ;IACR,cAAc;IACd,WAAW;IACX,KAAK;IACL,UAAU;IACV,UAAU;IACV,sBAAsB;IACtB,gBAAgB;IAChB,SAAS;IACT,kBAAkB;IAClB,mBAAmB;AACvB,EAAE"}\n//# sourceURL=webpack-internal:///../../framework/esm-translations/dist/translations.js\n\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n__webpack_require__.d(__webpack_exports__, {\n  coreTranslations: () => (coreTranslations)\n});\n/** Please keep these alphabetized */ const addressFields = {\n    address1: 'Address line 1',\n    address2: 'Address line 2',\n    address3: 'Address line 3',\n    address4: 'Address line 4',\n    address5: 'Address line 5',\n    address6: 'Address line 6',\n    city: 'City',\n    cityVillage: 'City',\n    country: 'Country',\n    countyDistrict: 'District',\n    district: 'District',\n    postalCode: 'Postal code',\n    state: 'State',\n    stateProvince: 'State'\n};\nconst workspaceTranslations = {\n    closeAllOpenedWorkspaces: 'Discard changes in {{count}} workspaces',\n    closingAllWorkspacesPromptBody: 'There may be unsaved changes in the following workspaces. Do you want to discard changes in the following workspaces? {{workspaceNames}}',\n    closingAllWorkspacesPromptTitle: 'You have unsaved changes',\n    discard: 'Discard',\n    hide: 'Hide',\n    maximize: 'Maximize',\n    minimize: 'Minimize',\n    openAnyway: 'Open anyway',\n    unsavedChangesInOpenedWorkspace: 'You may have unsaved changes in the opened workspace. Do you want to discard these changes?',\n    unsavedChangesInWorkspace: 'There may be unsaved changes in \"{{workspaceName}}\". Please save them before opening another workspace.',\n    unsavedChangesTitleText: 'Unsaved changes',\n    workspaceHeader: 'Workspace header'\n};\nconst workspace2Translations = {\n    discardUnsavedChangesPromptBodyMultiple: '{{count}} workspaces have unsaved changes. Closing them will discard the changes:',\n    discardUnsavedChangesPromptBodySingle: '<strong>{{workspaceTitle}}</strong> has unsaved changes. Closing it will discard them.',\n    discardUnsavedChangesPromptTitle: 'Discard unsaved changes?',\n    keepEditing: 'Keep editing'\n};\nconst coreTranslations = {\n    ...addressFields,\n    ...workspaceTranslations,\n    ...workspace2Translations,\n    abnormalValue: 'Abnormal value',\n    actions: 'Actions',\n    actionableNotification: 'Actionable notification',\n    address: 'Address',\n    age: 'Age',\n    applicationError: 'Application Error',\n    batchActionItemSelected: '{{totalSelected}} item selected',\n    batchActionsItemsSelected: '{{totalSelected}} items selected',\n    cancel: 'Cancel',\n    change: 'Change',\n    // Default value for the implementationName config property\n    Clinic: 'Clinic',\n    clearDevOverrides: 'Clear dev overrides',\n    close: 'Close',\n    closesActionableNotification: 'Close actionable notification',\n    closeSnackbar: 'Close snackbar',\n    confirm: 'Confirm',\n    contactAdministratorIfIssuePersists: 'Contact your system administrator if the problem persists.',\n    contactDetails: 'Contact details',\n    copied: 'Copied!',\n    copyToClipboard: 'Copy to clipboard',\n    delete: 'Delete',\n    discardChanges: 'Discard changes',\n    edit: 'Edit',\n    emptyStateText: 'There are no {{displayText}} to display',\n    error: 'Error',\n    errorCopy: 'Sorry, there was a problem displaying this information. You can try to reload this page, or contact the site administrator and quote the error code above.',\n    errorLoadingLoginLocations: 'Unable to load login locations. Please try again or contact support if the problem persists.',\n    female: 'Female',\n    leftNavigation: 'Left navigation',\n    loading: 'Loading',\n    localVersion: 'Local Build',\n    male: 'Male',\n    navigateNonHttp: 'Could not navigate to the requested page as it is not a safe URL',\n    noResultsToDisplay: 'No results to display',\n    notAvailable: 'Not available',\n    other: 'Other',\n    paginationItemsCount: '{{pageItemsCount}} / {{totalItems}} items',\n    paginationOfPages: 'of {{count}} pages',\n    patientAvatarAlt: 'Avatar for {{patientName}}',\n    patientIdentifierSticker: 'Patient identifier sticker',\n    patientLists: 'Patient lists',\n    patientPhotoAlt: 'Profile photo of {{patientName}}',\n    patientPhotoPlaceholder: 'Photo placeholder for {{patientName}}',\n    prereleaseVersion: 'Prerelease',\n    print: 'Print',\n    printError: 'Print error',\n    printErrorExplainer: 'An error occurred in {{errorLocation}}',\n    printIdentifierSticker: 'Print identifier sticker',\n    printing: 'Printing',\n    recordNewEntry: 'Record {{displayText}}',\n    relationships: 'Relationships',\n    reload: 'Reload',\n    resetOverrides: 'Reset overrides',\n    save: 'Save',\n    scriptLoadingFailed: 'Error: Script failed to load',\n    scriptLoadingError: 'Failed to load overridden script from {{url}}. Please check that the bundled script is available at the expected URL. Click the button below to reset all import map overrides.',\n    searchForLocation: 'Search for a location',\n    seeAll: 'See all',\n    seeMoreLists: 'See {{count}} more lists',\n    selectAll: 'Select all',\n    serverStartingUp: 'The server is starting',\n    serverStartingUpExplainer: 'This can take a few minutes. OpenMRS will open automatically when the server is ready.',\n    serverStartingUpSlowExplainer: 'This is taking longer than usual. First startup after an upgrade can take 10 minutes or more. You can leave this page open.',\n    sex: 'Sex',\n    showLess: 'Show less',\n    showMore: 'Show more',\n    snackbarNotification: 'Snackbar notification',\n    somethingWentWrongTryReloading: 'Something went wrong. Please try reloading.',\n    toggleDevTools: 'Toggle dev tools',\n    unknown: 'Unknown',\n    viewSetupProgress: 'View setup progress',\n    waitingForServer: 'Waiting for the server',\n    yearAbbreviation: 'yr',\n    yearsAbbreviation: 'yrs'\n};\n\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"javascript/esm|builtin:swc-loader??ruleSet[1].rules[5].use[0]!/home/runner/work/openmrs-esm-core/openmrs-esm-core/packages/framework/esm-translations/dist/translations.js","sources":["webpack://@openmrs/esm-app-shell/../../framework/esm-translations/dist/translations.js?90df"],"sourcesContent":["/** Please keep these alphabetized */ const addressFields = {\n    address1: 'Address line 1',\n    address2: 'Address line 2',\n    address3: 'Address line 3',\n    address4: 'Address line 4',\n    address5: 'Address line 5',\n    address6: 'Address line 6',\n    city: 'City',\n    cityVillage: 'City',\n    country: 'Country',\n    countyDistrict: 'District',\n    district: 'District',\n    postalCode: 'Postal code',\n    state: 'State',\n    stateProvince: 'State'\n};\nconst workspaceTranslations = {\n    closeAllOpenedWorkspaces: 'Discard changes in {{count}} workspaces',\n    closingAllWorkspacesPromptBody: 'There may be unsaved changes in the following workspaces. Do you want to discard changes in the following workspaces? {{workspaceNames}}',\n    closingAllWorkspacesPromptTitle: 'You have unsaved changes',\n    discard: 'Discard',\n    hide: 'Hide',\n    maximize: 'Maximize',\n    minimize: 'Minimize',\n    openAnyway: 'Open anyway',\n    unsavedChangesInOpenedWorkspace: 'You may have unsaved changes in the opened workspace. Do you want to discard these changes?',\n    unsavedChangesInWorkspace: 'There may be unsaved changes in \"{{workspaceName}}\". Please save them before opening another workspace.',\n    unsavedChangesTitleText: 'Unsaved changes',\n    workspaceHeader: 'Workspace header'\n};\nconst workspace2Translations = {\n    discardUnsavedChangesPromptBodyMultiple: '{{count}} workspaces have unsaved changes. Closing them will discard the changes:',\n    discardUnsavedChangesPromptBodySingle: '<strong>{{workspaceTitle}}</strong> has unsaved changes. Closing it will discard them.',\n    discardUnsavedChangesPromptTitle: 'Discard unsaved changes?',\n    keepEditing: 'Keep editing'\n};\nexport const coreTranslations = {\n    ...addressFields,\n    ...workspaceTranslations,\n    ...workspace2Translations,\n    abnormalValue: 'Abnormal value',\n    actions: 'Actions',\n    actionableNotification: 'Actionable notification',\n    address: 'Address',\n    age: 'Age',\n    applicationError: 'Application Error',\n    batchActionItemSelected: '{{totalSelected}} item selected',\n    batchActionsItemsSelected: '{{totalSelected}} items selected',\n    cancel: 'Cancel',\n    change: 'Change',\n    // Default value for the implementationName config property\n    Clinic: 'Clinic',\n    clearDevOverrides: 'Clear dev overrides',\n    close: 'Close',\n    closesActionableNotification: 'Close actionable notification',\n    closeSnackbar: 'Close snackbar',\n    confirm: 'Confirm',\n    contactAdministratorIfIssuePersists: 'Contact your system administrator if the problem persists.',\n    contactDetails: 'Contact details',\n    copied: 'Copied!',\n    copyToClipboard: 'Copy to clipboard',\n    delete: 'Delete',\n    discardChanges: 'Discard changes',\n    edit: 'Edit',\n    emptyStateText: 'There are no {{displayText}} to display',\n    error: 'Error',\n    errorCopy: 'Sorry, there was a problem displaying this information. You can try to reload this page, or contact the site administrator and quote the error code above.',\n    errorLoadingLoginLocations: 'Unable to load login locations. Please try again or contact support if the problem persists.',\n    female: 'Female',\n    leftNavigation: 'Left navigation',\n    loading: 'Loading',\n    localVersion: 'Local Build',\n    male: 'Male',\n    navigateNonHttp: 'Could not navigate to the requested page as it is not a safe URL',\n    noResultsToDisplay: 'No results to display',\n    notAvailable: 'Not available',\n    other: 'Other',\n    paginationItemsCount: '{{pageItemsCount}} / {{totalItems}} items',\n    paginationOfPages: 'of {{count}} pages',\n    patientAvatarAlt: 'Avatar for {{patientName}}',\n    patientIdentifierSticker: 'Patient identifier sticker',\n    patientLists: 'Patient lists',\n    patientPhotoAlt: 'Profile photo of {{patientName}}',\n    patientPhotoPlaceholder: 'Photo placeholder for {{patientName}}',\n    prereleaseVersion: 'Prerelease',\n    print: 'Print',\n    printError: 'Print error',\n    printErrorExplainer: 'An error occurred in {{errorLocation}}',\n    printIdentifierSticker: 'Print identifier sticker',\n    printing: 'Printing',\n    recordNewEntry: 'Record {{displayText}}',\n    relationships: 'Relationships',\n    reload: 'Reload',\n    resetOverrides: 'Reset overrides',\n    save: 'Save',\n    scriptLoadingFailed: 'Error: Script failed to load',\n    scriptLoadingError: 'Failed to load overridden script from {{url}}. Please check that the bundled script is available at the expected URL. Click the button below to reset all import map overrides.',\n    searchForLocation: 'Search for a location',\n    seeAll: 'See all',\n    seeMoreLists: 'See {{count}} more lists',\n    selectAll: 'Select all',\n    serverStartingUp: 'The server is starting',\n    serverStartingUpExplainer: 'This can take a few minutes. OpenMRS will open automatically when the server is ready.',\n    serverStartingUpSlowExplainer: 'This is taking longer than usual. First startup after an upgrade can take 10 minutes or more. You can leave this page open.',\n    sex: 'Sex',\n    showLess: 'Show less',\n    showMore: 'Show more',\n    snackbarNotification: 'Snackbar notification',\n    somethingWentWrongTryReloading: 'Something went wrong. Please try reloading.',\n    toggleDevTools: 'Toggle dev tools',\n    unknown: 'Unknown',\n    viewSetupProgress: 'View setup progress',\n    waitingForServer: 'Waiting for the server',\n    yearAbbreviation: 'yr',\n    yearsAbbreviation: 'yrs'\n};\n"],"names":["addressFields","workspaceTranslations","workspace2Translations","coreTranslations"],"mappings":";;;;AAAA,mCAAmC,GAAG,MAAMA,gBAAgB;IACxD,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IACV,MAAM;IACN,aAAa;IACb,SAAS;IACT,gBAAgB;IAChB,UAAU;IACV,YAAY;IACZ,OAAO;IACP,eAAe;AACnB;AACA,MAAMC,wBAAwB;IAC1B,0BAA0B;IAC1B,gCAAgC;IAChC,iCAAiC;IACjC,SAAS;IACT,MAAM;IACN,UAAU;IACV,UAAU;IACV,YAAY;IACZ,iCAAiC;IACjC,2BAA2B;IAC3B,yBAAyB;IACzB,iBAAiB;AACrB;AACA,MAAMC,yBAAyB;IAC3B,yCAAyC;IACzC,uCAAuC;IACvC,kCAAkC;IAClC,aAAa;AACjB;AACO,MAAMC,mBAAmB;IAC5B,GAAGH,aAAa;IAChB,GAAGC,qBAAqB;IACxB,GAAGC,sBAAsB;IACzB,eAAe;IACf,SAAS;IACT,wBAAwB;IACxB,SAAS;IACT,KAAK;IACL,kBAAkB;IAClB,yBAAyB;IACzB,2BAA2B;IAC3B,QAAQ;IACR,QAAQ;IACR,2DAA2D;IAC3D,QAAQ;IACR,mBAAmB;IACnB,OAAO;IACP,8BAA8B;IAC9B,eAAe;IACf,SAAS;IACT,qCAAqC;IACrC,gBAAgB;IAChB,QAAQ;IACR,iBAAiB;IACjB,QAAQ;IACR,gBAAgB;IAChB,MAAM;IACN,gBAAgB;IAChB,OAAO;IACP,WAAW;IACX,4BAA4B;IAC5B,QAAQ;IACR,gBAAgB;IAChB,SAAS;IACT,cAAc;IACd,MAAM;IACN,iBAAiB;IACjB,oBAAoB;IACpB,cAAc;IACd,OAAO;IACP,sBAAsB;IACtB,mBAAmB;IACnB,kBAAkB;IAClB,0BAA0B;IAC1B,cAAc;IACd,iBAAiB;IACjB,yBAAyB;IACzB,mBAAmB;IACnB,OAAO;IACP,YAAY;IACZ,qBAAqB;IACrB,wBAAwB;IACxB,UAAU;IACV,gBAAgB;IAChB,eAAe;IACf,QAAQ;IACR,gBAAgB;IAChB,MAAM;IACN,qBAAqB;IACrB,oBAAoB;IACpB,mBAAmB;IACnB,QAAQ;IACR,cAAc;IACd,WAAW;IACX,kBAAkB;IAClB,2BAA2B;IAC3B,+BAA+B;IAC/B,KAAK;IACL,UAAU;IACV,UAAU;IACV,sBAAsB;IACtB,gCAAgC;IAChC,gBAAgB;IAChB,SAAS;IACT,mBAAmB;IACnB,kBAAkB;IAClB,kBAAkB;IAClB,mBAAmB;AACvB,EAAE"}\n//# sourceURL=webpack-internal:///../../framework/esm-translations/dist/translations.js\n\n}");
 
 },
 "../../framework/esm-utils/dist/age-helpers.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {