@itwin/core-i18n 3.7.0-dev.5 → 3.7.0-dev.7

package/lib/cjs/test/webpack/bundled-tests.instrumented.js

@@ -10,20 +10,20 @@
 "use strict";
 
 
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Localization
+/** @packageDocumentation
+ * @module Localization
  */
-function cov_a3gxtmyvj() {
-  var path = "D:\\vsts_b\\57\\s\\core\\i18n\\lib\\cjs\\ITwinLocalization.js";
-  var hash = "792cee55a98eb07529fe29275d9b77f39664df54";
+function cov_2l9mmpbx71() {
+  var path = "D:\\vsts_a\\4\\s\\core\\i18n\\lib\\cjs\\ITwinLocalization.js";
+  var hash = "24e58bea480e0876d4033d5608415d9c06c3e4a5";
   var global = new Function("return this")();
   var gcv = "__coverage__";
   var coverageData = {
-    path: "D:\\vsts_b\\57\\s\\core\\i18n\\lib\\cjs\\ITwinLocalization.js",
+    path: "D:\\vsts_a\\4\\s\\core\\i18n\\lib\\cjs\\ITwinLocalization.js",
     statementMap: {
       "0": {
         start: {
@@ -3086,13 +3086,13 @@ function cov_a3gxtmyvj() {
     inputSourceMap: {
       version: 3,
       file: "ITwinLocalization.js",
-      sources: ["D:\\vsts_b\\57\\s\\core\\i18n\\src\\ITwinLocalization.ts"],
+      sources: ["D:\\vsts_a\\4\\s\\core\\i18n\\src\\ITwinLocalization.ts"],
       names: [],
       mappings: ";AAAA;;;+FAG+F;AAC/F;;GAEG;;;;;;AAEH,sDAA2E;AAC3E,wGAAmG;AACnG,gFAA+D;AAC/D,sDAA6C;AAG7C,MAAM,mBAAmB,GAAW,CAAC,CAAC,CAAC,8GAA8G;AAcrJ;;;GAGG;AACH,MAAa,iBAAiB;IAO5B,YAAmB,OAA6B;;QAF/B,gBAAW,GAAG,IAAI,GAAG,EAAyB,CAAC;QAG9D,IAAI,CAAC,OAAO,GAAG,iBAAO,CAAC,cAAc,EAAE,CAAC;QAExC,IAAI,CAAC,eAAe,GAAG;YACrB,QAAQ,EAAE,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW,mCAAI,6BAA6B;YAC/D,WAAW,EAAE,IAAI;YACjB,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,kBAAkB;SAC/B,CAAC;QAEF,IAAI,CAAC,iBAAiB,GAAG;YACvB,KAAK,EAAE,CAAC,aAAa,EAAE,WAAW,EAAE,SAAS,CAAC;YAC9C,iBAAiB,EAAE,KAAK;YACxB,MAAM,EAAE,EAAE;YACV,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,eAAe;SAC5B,CAAC;QAEF,IAAI,CAAC,YAAY,GAAG;YAClB,aAAa,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;YACpC,WAAW,EAAE,IAAI;YACjB,UAAU,EAAE,mBAAmB;YAC/B,OAAO,EAAE,IAAI,CAAC,eAAe;YAC7B,SAAS,EAAE,IAAI,CAAC,iBAAiB;YACjC,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW;SACxB,CAAC;QAEF,IAAI,CAAC,OAAO;aACT,GAAG,CAAC,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,cAAc,mCAAI,0CAA8B,CAAC;aAC9D,GAAG,CAAC,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,mCAAI,8BAAO,CAAC;aACtC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC5B,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,UAAoB;;QAE1C,mDAAmD;QACnD,MAAM,cAAc,GAAa,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACrE,MAAM,kBAAkB,GAAgB,IAAI,GAAG,CAAC,CAAC,GAAG,UAAU,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,qBAAqB;QAE1G,MAAM,gBAAgB,GAAuC,MAAA,IAAI,CAAC,YAAY,CAAC,SAAS,mCAAI,UAAU,CAAC,CAAC,CAAC,CAAC;QAC1G,IAAI,gBAAgB;YAClB,kBAAkB,CAAC,GAAG,CAAC,gBAA0B,CAAC,CAAC,CAAC,oDAAoD;QAE1G,MAAM,WAAW,GAAgB;YAC/B,GAAG,IAAI,CAAC,YAAY;YACpB,SAAS,EAAE,gBAAgB;YAC3B,EAAE,EAAE,CAAC,GAAG,kBAAkB,CAAC;SAC5B,CAAC;QAEF,iDAAiD;QACjD,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa;YACxC,WAAW,CAAC,KAAK,GAAG,IAAI,CAAC;QAE3B,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAA6B,CAAC;QAE/E,KAAK,MAAM,EAAE,IAAI,UAAU;YACzB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;QAExC,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,gBAAgB,CAAC,IAAY;QAClC,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,kBAAkB,CAAC,GAAsB,EAAE,OAAsB;QACtE,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,MAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,CAAA,EAAE;YACpD,MAAM,IAAI,KAAK,CAAC,sFAAsF,CAAC,CAAC;SACzG;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QAE3C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;SACxD;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACI,+BAA+B,CAAC,SAAiB,EAAE,GAAsB,EAAE,OAAsB;QACtG,IAAI,OAAO,GAAsB,EAAE,CAAC;QAEpC,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;YAC3B,OAAO,GAAG,GAAG,SAAS,IAAI,GAAG,EAAE,CAAC;SACjC;aAAM;YACL,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;gBACnC,OAAO,GAAG,SAAS,IAAI,MAAM,EAAE,CAAC;YAClC,CAAC,CAAC,CAAC;SACJ;QAED,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;OAMG;IACI,gBAAgB,CAAC,SAAiB,EAAE,GAAsB,EAAE,OAAsB;QACvF,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,MAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,CAAA,EAAE;YACpD,MAAM,IAAI,KAAK,CAAC,sFAAsF,CAAC,CAAC;SACzG;QAED,OAAO,GAAG;YACR,GAAG,OAAO;YACV,EAAE,EAAE,SAAS,EAAE,oCAAoC;SACpD,CAAC;QAEF,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACnD,MAAM,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QAC7B,IAAI,OAAO,GAAG,KAAK,QAAQ;YACzB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAElD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;OAGG;IACI,mBAAmB,CAAC,IAAY;QACrC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED,gBAAgB;IACT,eAAe;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;IAChC,CAAC;IAED,qDAAqD;IAC9C,KAAK,CAAC,cAAc,CAAC,QAAgB;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAA6B,CAAC;IAC3E,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,iBAAiB,CAAC,IAAY;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,QAAQ,KAAK,SAAS;YACxB,OAAO,QAAQ,CAAC;QAElB,MAAM,cAAc,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACnD,mEAAmE;YACnE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE;gBACxC,IAAI,CAAC,GAAG;oBACN,OAAO,OAAO,EAAE,CAAC;gBAEnB,qCAAqC;gBACrC,yHAAyH;gBACzH,2GAA2G;gBAC3G,8HAA8H;gBAC9H,8IAA8I;gBAC9I,IAAI,OAAO,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC,GAAG,CAAC,CAAC,UAAe,EAAE,EAAE,CAAC,IAAI,UAAU,GAAG,CAAC,CAAC;gBAEjF,IAAI;oBACF,KAAK,MAAM,SAAS,IAAI,GAAG,EAAE;wBAC3B,IAAI,OAAO,SAAS,KAAK,QAAQ;4BAC/B,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;qBAC7E;iBACF;gBAAC,OAAO,CAAC,EAAE;oBACV,OAAO,GAAG,EAAE,CAAC;iBACd;gBACD,+DAA+D;gBAC/D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;oBACtB,qBAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,8BAA8B,IAAI,kBAAkB,CAAC,CAAC;gBAEhF,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;QAC3C,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,gBAAgB;IACT,mBAAmB,CAAC,IAAY;QACrC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;CACF;AAnOD,8CAmOC;AAED,MAAM,iBAAiB;IAEd,GAAG,CAAC,IAAc,IAAI,qBAAM,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5E,IAAI,CAAC,IAAc,IAAI,qBAAM,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAChF,KAAK,CAAC,IAAc,IAAI,qBAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,gBAAgB,CAAC,IAAc;QACrC,IAAI,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;YACpC,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ;gBAC7B,OAAO,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;SAC/B;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;;AAXsB,sBAAI,GAAG,QAAQ,CAAC",
-      sourcesContent: ["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Localization\n */\n\nimport i18next, { i18n, InitOptions, Module, TOptionsBase } from \"i18next\";\nimport i18nextBrowserLanguageDetector, { DetectorOptions } from \"i18next-browser-languagedetector\";\nimport Backend, { BackendOptions } from \"i18next-http-backend\";\nimport { Logger } from \"@itwin/core-bentley\";\nimport type { Localization } from \"@itwin/core-common\";\n\nconst DEFAULT_MAX_RETRIES: number = 1; // a low number prevents wasted time and potential timeouts when requesting localization files throws an error\n\n/** Options for ITwinLocalization\n *  @public\n */\nexport interface LocalizationOptions {\n  urlTemplate?: string;\n  backendPlugin?: Module;\n  detectorPlugin?: Module;\n  initOptions?: InitOptions;\n  backendHttpOptions?: BackendOptions;\n  detectorOptions?: DetectorOptions;\n}\n\n/** Supplies localizations for iTwin.js\n * @note this class uses the [i18next](https://www.i18next.com/) package.\n * @public\n */\nexport class ITwinLocalization implements Localization {\n  public i18next: i18n;\n  private readonly _initOptions: InitOptions;\n  private readonly _backendOptions: BackendOptions;\n  private readonly _detectionOptions: DetectorOptions;\n  private readonly _namespaces = new Map<string, Promise<void>>();\n\n  public constructor(options?: LocalizationOptions) {\n    this.i18next = i18next.createInstance();\n\n    this._backendOptions = {\n      loadPath: options?.urlTemplate ?? \"locales/{{lng}}/{{ns}}.json\",\n      crossDomain: true,\n      ...options?.backendHttpOptions,\n    };\n\n    this._detectionOptions = {\n      order: [\"querystring\", \"navigator\", \"htmlTag\"],\n      lookupQuerystring: \"lng\",\n      caches: [],\n      ...options?.detectorOptions,\n    };\n\n    this._initOptions = {\n      interpolation: { escapeValue: true },\n      fallbackLng: \"en\",\n      maxRetries: DEFAULT_MAX_RETRIES,\n      backend: this._backendOptions,\n      detection: this._detectionOptions,\n      ...options?.initOptions,\n    };\n\n    this.i18next\n      .use(options?.detectorPlugin ?? i18nextBrowserLanguageDetector)\n      .use(options?.backendPlugin ?? Backend)\n      .use(TranslationLogger);\n  }\n\n  public async initialize(namespaces: string[]): Promise<void> {\n\n    // Also consider namespaces passed into constructor\n    const initNamespaces: string[] = [this._initOptions.ns || []].flat();\n    const combinedNamespaces: Set<string> = new Set([...namespaces, ...initNamespaces]); // without duplicates\n\n    const defaultNamespace: string | false | readonly string[] = this._initOptions.defaultNS ?? namespaces[0];\n    if (defaultNamespace)\n      combinedNamespaces.add(defaultNamespace as string); // Make sure default namespace is in namespaces list\n\n    const initOptions: InitOptions = {\n      ...this._initOptions,\n      defaultNS: defaultNamespace,\n      ns: [...combinedNamespaces],\n    };\n\n    // if in a development environment, set debugging\n    if (process.env.NODE_ENV === \"development\")\n      initOptions.debug = true;\n\n    const initPromise = this.i18next.init(initOptions) as unknown as Promise<void>;\n\n    for (const ns of namespaces)\n      this._namespaces.set(ns, initPromise);\n\n    return initPromise;\n  }\n\n  /** Replace all instances of `%{key}` within a string with the translations of those keys.\n   * For example:\n   * ``` ts\n   * \"MyKeys\": {\n   *   \"Key1\": \"First value\",\n   *   \"Key2\": \"Second value\"\n   *  }\n   * ```\n   *\n   * ``` ts\n   * i18.translateKeys(\"string with %{MyKeys.Key1} followed by %{MyKeys.Key2}!\"\") // returns \"string with First Value followed by Second Value!\"\n   * ```\n   * @param line The input line, potentially containing %{keys}.\n   * @returns The line with all %{keys} translated\n   * @public\n   */\n  public getLocalizedKeys(line: string): string {\n    return line.replace(/\\%\\{(.+?)\\}/g, (_match, tag) => this.getLocalizedString(tag));\n  }\n\n  /** Return the translated value of a key.\n   * @param key - the key that matches a property in the JSON localization file.\n   * @note The key includes the namespace, which identifies the particular localization file that contains the property,\n   * followed by a colon, followed by the property in the JSON file.\n   * For example:\n   * ``` ts\n   * const dataString: string = IModelApp.localization.getLocalizedString(\"iModelJs:BackgroundMap.BingDataAttribution\");\n   *  ```\n   * assigns to dataString the string with property BackgroundMap.BingDataAttribution from the iModelJs.json localization file.\n   * @returns The string corresponding to the first key that resolves.\n   * @throws Error if no keys resolve to a string.\n   * @public\n   */\n  public getLocalizedString(key: string | string[], options?: TOptionsBase): string {\n    if (options?.returnDetails || options?.returnObjects) {\n      throw new Error(\"Translation key must map to a string, but the given options will result in an object\");\n    }\n\n    const value = this.i18next.t(key, options);\n\n    if (typeof value !== \"string\") {\n      throw new Error(\"Translation key(s) string not found\");\n    }\n\n    return value;\n  }\n\n  /** Similar to `getLocalizedString` but the default namespace is a separate parameter and the key does not need\n   * to include a namespace. If a key includes a namespace, that namespace will be used for interpolating that key.\n   * @param namespace - the namespace that identifies the particular localization file that contains the property.\n   * @param key - the key that matches a property in the JSON localization file.\n   * @returns The string corresponding to the first key that resolves.\n   * @throws Error if no keys resolve to a string.\n   * @internal\n   */\n  public getLocalizedStringWithNamespace(namespace: string, key: string | string[], options?: TOptionsBase): string {\n    let fullKey: string | string[] = \"\";\n\n    if (typeof key === \"string\") {\n      fullKey = `${namespace}:${key}`;\n    } else {\n      fullKey = key.map((subKey: string) => {\n        return `${namespace}:${subKey}`;\n      });\n    }\n\n    return this.getLocalizedString(fullKey, options);\n  }\n\n  /** Gets the English translation.\n   * @param namespace - the namespace that identifies the particular localization file that contains the property.\n   * @param key - the key that matches a property in the JSON localization file.\n   * @returns The string corresponding to the first key that resolves.\n   * @throws Error if no keys resolve to a string.\n   * @internal\n   */\n  public getEnglishString(namespace: string, key: string | string[], options?: TOptionsBase): string {\n    if (options?.returnDetails || options?.returnObjects) {\n      throw new Error(\"Translation key must map to a string, but the given options will result in an object\");\n    }\n\n    options = {\n      ...options,\n      ns: namespace, // ensure namespace argument is used\n    };\n\n    const en = this.i18next.getFixedT(\"en\", namespace);\n    const str = en(key, options);\n    if (typeof str !== \"string\")\n      throw new Error(\"Translation key(s) not found\");\n\n    return str;\n  }\n\n  /** Get the promise for an already registered Namespace.\n   * @param name - the name of the namespace\n   * @public\n   */\n  public getNamespacePromise(name: string): Promise<void> | undefined {\n    return this._namespaces.get(name);\n  }\n\n  /** @internal */\n  public getLanguageList(): readonly string[] {\n    return this.i18next.languages;\n  }\n\n  /** override the language detected in the browser  */\n  public async changeLanguage(language: string) {\n    return this.i18next.changeLanguage(language) as unknown as Promise<void>;\n  }\n\n  /** Register a new Namespace and return it. If the namespace is already registered, it will be returned.\n   * @param name - the name of the namespace, which is the base name of the JSON file that contains the localization properties.\n   * @note - The registerNamespace method starts fetching the appropriate version of the JSON localization file from the server,\n   * based on the current locale. To make sure that fetch is complete before performing translations from this namespace, await\n   * fulfillment of the readPromise Promise property of the returned LocalizationNamespace.\n   * @see [Localization in iTwin.js]($docs/learning/frontend/Localization.md)\n   * @public\n   */\n  public async registerNamespace(name: string): Promise<void> {\n    const existing = this._namespaces.get(name);\n    if (existing !== undefined)\n      return existing;\n\n    const theReadPromise = new Promise<void>((resolve) => {\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.i18next.loadNamespaces(name, (err) => {\n        if (!err)\n          return resolve();\n\n        // Here we got a non-null err object.\n        // This method is called when the system has attempted to load the resources for the namespaces for each possible locale.\n        // For example 'fr-ca' might be the most specific locale, in which case 'fr' and 'en' are fallback locales.\n        // Using Backend from i18next-http-backend, err will be an array of strings of each namespace it tried to read and its locale.\n        // There might be errs for some other namespaces as well as this one. We resolve the promise unless there's an error for each possible locale.\n        let locales = this.getLanguageList().map((thisLocale: any) => `/${thisLocale}/`);\n\n        try {\n          for (const thisError of err) {\n            if (typeof thisError === \"string\")\n              locales = locales.filter((thisLocale) => !thisError.includes(thisLocale));\n          }\n        } catch (e) {\n          locales = [];\n        }\n        // if we removed every locale from the array, it wasn't loaded.\n        if (locales.length === 0)\n          Logger.logError(\"i18n\", `No resources for namespace ${name} could be loaded`);\n\n        resolve();\n      });\n    });\n    this._namespaces.set(name, theReadPromise);\n    return theReadPromise;\n  }\n\n  /** @internal */\n  public unregisterNamespace(name: string): void {\n    this._namespaces.delete(name);\n  }\n}\n\nclass TranslationLogger {\n  public static readonly type = \"logger\";\n  public log(args: string[]) { Logger.logInfo(\"i18n\", this.createLogMessage(args)); }\n  public warn(args: string[]) { Logger.logWarning(\"i18n\", this.createLogMessage(args)); }\n  public error(args: string[]) { Logger.logError(\"i18n\", this.createLogMessage(args)); }\n  private createLogMessage(args: string[]) {\n    let message = args[0];\n    for (let i = 1; i < args.length; ++i) {\n      if (typeof args[i] === \"string\")\n        message += `\\n  ${args[i]}`;\n    }\n    return message;\n  }\n}\n"]
+      sourcesContent: ["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Localization\r\n */\r\n\r\nimport i18next, { i18n, InitOptions, Module, TOptionsBase } from \"i18next\";\r\nimport i18nextBrowserLanguageDetector, { DetectorOptions } from \"i18next-browser-languagedetector\";\r\nimport Backend, { BackendOptions } from \"i18next-http-backend\";\r\nimport { Logger } from \"@itwin/core-bentley\";\r\nimport type { Localization } from \"@itwin/core-common\";\r\n\r\nconst DEFAULT_MAX_RETRIES: number = 1; // a low number prevents wasted time and potential timeouts when requesting localization files throws an error\r\n\r\n/** Options for ITwinLocalization\r\n *  @public\r\n */\r\nexport interface LocalizationOptions {\r\n  urlTemplate?: string;\r\n  backendPlugin?: Module;\r\n  detectorPlugin?: Module;\r\n  initOptions?: InitOptions;\r\n  backendHttpOptions?: BackendOptions;\r\n  detectorOptions?: DetectorOptions;\r\n}\r\n\r\n/** Supplies localizations for iTwin.js\r\n * @note this class uses the [i18next](https://www.i18next.com/) package.\r\n * @public\r\n */\r\nexport class ITwinLocalization implements Localization {\r\n  public i18next: i18n;\r\n  private readonly _initOptions: InitOptions;\r\n  private readonly _backendOptions: BackendOptions;\r\n  private readonly _detectionOptions: DetectorOptions;\r\n  private readonly _namespaces = new Map<string, Promise<void>>();\r\n\r\n  public constructor(options?: LocalizationOptions) {\r\n    this.i18next = i18next.createInstance();\r\n\r\n    this._backendOptions = {\r\n      loadPath: options?.urlTemplate ?? \"locales/{{lng}}/{{ns}}.json\",\r\n      crossDomain: true,\r\n      ...options?.backendHttpOptions,\r\n    };\r\n\r\n    this._detectionOptions = {\r\n      order: [\"querystring\", \"navigator\", \"htmlTag\"],\r\n      lookupQuerystring: \"lng\",\r\n      caches: [],\r\n      ...options?.detectorOptions,\r\n    };\r\n\r\n    this._initOptions = {\r\n      interpolation: { escapeValue: true },\r\n      fallbackLng: \"en\",\r\n      maxRetries: DEFAULT_MAX_RETRIES,\r\n      backend: this._backendOptions,\r\n      detection: this._detectionOptions,\r\n      ...options?.initOptions,\r\n    };\r\n\r\n    this.i18next\r\n      .use(options?.detectorPlugin ?? i18nextBrowserLanguageDetector)\r\n      .use(options?.backendPlugin ?? Backend)\r\n      .use(TranslationLogger);\r\n  }\r\n\r\n  public async initialize(namespaces: string[]): Promise<void> {\r\n\r\n    // Also consider namespaces passed into constructor\r\n    const initNamespaces: string[] = [this._initOptions.ns || []].flat();\r\n    const combinedNamespaces: Set<string> = new Set([...namespaces, ...initNamespaces]); // without duplicates\r\n\r\n    const defaultNamespace: string | false | readonly string[] = this._initOptions.defaultNS ?? namespaces[0];\r\n    if (defaultNamespace)\r\n      combinedNamespaces.add(defaultNamespace as string); // Make sure default namespace is in namespaces list\r\n\r\n    const initOptions: InitOptions = {\r\n      ...this._initOptions,\r\n      defaultNS: defaultNamespace,\r\n      ns: [...combinedNamespaces],\r\n    };\r\n\r\n    // if in a development environment, set debugging\r\n    if (process.env.NODE_ENV === \"development\")\r\n      initOptions.debug = true;\r\n\r\n    const initPromise = this.i18next.init(initOptions) as unknown as Promise<void>;\r\n\r\n    for (const ns of namespaces)\r\n      this._namespaces.set(ns, initPromise);\r\n\r\n    return initPromise;\r\n  }\r\n\r\n  /** Replace all instances of `%{key}` within a string with the translations of those keys.\r\n   * For example:\r\n   * ``` ts\r\n   * \"MyKeys\": {\r\n   *   \"Key1\": \"First value\",\r\n   *   \"Key2\": \"Second value\"\r\n   *  }\r\n   * ```\r\n   *\r\n   * ``` ts\r\n   * i18.translateKeys(\"string with %{MyKeys.Key1} followed by %{MyKeys.Key2}!\"\") // returns \"string with First Value followed by Second Value!\"\r\n   * ```\r\n   * @param line The input line, potentially containing %{keys}.\r\n   * @returns The line with all %{keys} translated\r\n   * @public\r\n   */\r\n  public getLocalizedKeys(line: string): string {\r\n    return line.replace(/\\%\\{(.+?)\\}/g, (_match, tag) => this.getLocalizedString(tag));\r\n  }\r\n\r\n  /** Return the translated value of a key.\r\n   * @param key - the key that matches a property in the JSON localization file.\r\n   * @note The key includes the namespace, which identifies the particular localization file that contains the property,\r\n   * followed by a colon, followed by the property in the JSON file.\r\n   * For example:\r\n   * ``` ts\r\n   * const dataString: string = IModelApp.localization.getLocalizedString(\"iModelJs:BackgroundMap.BingDataAttribution\");\r\n   *  ```\r\n   * assigns to dataString the string with property BackgroundMap.BingDataAttribution from the iModelJs.json localization file.\r\n   * @returns The string corresponding to the first key that resolves.\r\n   * @throws Error if no keys resolve to a string.\r\n   * @public\r\n   */\r\n  public getLocalizedString(key: string | string[], options?: TOptionsBase): string {\r\n    if (options?.returnDetails || options?.returnObjects) {\r\n      throw new Error(\"Translation key must map to a string, but the given options will result in an object\");\r\n    }\r\n\r\n    const value = this.i18next.t(key, options);\r\n\r\n    if (typeof value !== \"string\") {\r\n      throw new Error(\"Translation key(s) string not found\");\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  /** Similar to `getLocalizedString` but the default namespace is a separate parameter and the key does not need\r\n   * to include a namespace. If a key includes a namespace, that namespace will be used for interpolating that key.\r\n   * @param namespace - the namespace that identifies the particular localization file that contains the property.\r\n   * @param key - the key that matches a property in the JSON localization file.\r\n   * @returns The string corresponding to the first key that resolves.\r\n   * @throws Error if no keys resolve to a string.\r\n   * @internal\r\n   */\r\n  public getLocalizedStringWithNamespace(namespace: string, key: string | string[], options?: TOptionsBase): string {\r\n    let fullKey: string | string[] = \"\";\r\n\r\n    if (typeof key === \"string\") {\r\n      fullKey = `${namespace}:${key}`;\r\n    } else {\r\n      fullKey = key.map((subKey: string) => {\r\n        return `${namespace}:${subKey}`;\r\n      });\r\n    }\r\n\r\n    return this.getLocalizedString(fullKey, options);\r\n  }\r\n\r\n  /** Gets the English translation.\r\n   * @param namespace - the namespace that identifies the particular localization file that contains the property.\r\n   * @param key - the key that matches a property in the JSON localization file.\r\n   * @returns The string corresponding to the first key that resolves.\r\n   * @throws Error if no keys resolve to a string.\r\n   * @internal\r\n   */\r\n  public getEnglishString(namespace: string, key: string | string[], options?: TOptionsBase): string {\r\n    if (options?.returnDetails || options?.returnObjects) {\r\n      throw new Error(\"Translation key must map to a string, but the given options will result in an object\");\r\n    }\r\n\r\n    options = {\r\n      ...options,\r\n      ns: namespace, // ensure namespace argument is used\r\n    };\r\n\r\n    const en = this.i18next.getFixedT(\"en\", namespace);\r\n    const str = en(key, options);\r\n    if (typeof str !== \"string\")\r\n      throw new Error(\"Translation key(s) not found\");\r\n\r\n    return str;\r\n  }\r\n\r\n  /** Get the promise for an already registered Namespace.\r\n   * @param name - the name of the namespace\r\n   * @public\r\n   */\r\n  public getNamespacePromise(name: string): Promise<void> | undefined {\r\n    return this._namespaces.get(name);\r\n  }\r\n\r\n  /** @internal */\r\n  public getLanguageList(): readonly string[] {\r\n    return this.i18next.languages;\r\n  }\r\n\r\n  /** override the language detected in the browser  */\r\n  public async changeLanguage(language: string) {\r\n    return this.i18next.changeLanguage(language) as unknown as Promise<void>;\r\n  }\r\n\r\n  /** Register a new Namespace and return it. If the namespace is already registered, it will be returned.\r\n   * @param name - the name of the namespace, which is the base name of the JSON file that contains the localization properties.\r\n   * @note - The registerNamespace method starts fetching the appropriate version of the JSON localization file from the server,\r\n   * based on the current locale. To make sure that fetch is complete before performing translations from this namespace, await\r\n   * fulfillment of the readPromise Promise property of the returned LocalizationNamespace.\r\n   * @see [Localization in iTwin.js]($docs/learning/frontend/Localization.md)\r\n   * @public\r\n   */\r\n  public async registerNamespace(name: string): Promise<void> {\r\n    const existing = this._namespaces.get(name);\r\n    if (existing !== undefined)\r\n      return existing;\r\n\r\n    const theReadPromise = new Promise<void>((resolve) => {\r\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n      this.i18next.loadNamespaces(name, (err) => {\r\n        if (!err)\r\n          return resolve();\r\n\r\n        // Here we got a non-null err object.\r\n        // This method is called when the system has attempted to load the resources for the namespaces for each possible locale.\r\n        // For example 'fr-ca' might be the most specific locale, in which case 'fr' and 'en' are fallback locales.\r\n        // Using Backend from i18next-http-backend, err will be an array of strings of each namespace it tried to read and its locale.\r\n        // There might be errs for some other namespaces as well as this one. We resolve the promise unless there's an error for each possible locale.\r\n        let locales = this.getLanguageList().map((thisLocale: any) => `/${thisLocale}/`);\r\n\r\n        try {\r\n          for (const thisError of err) {\r\n            if (typeof thisError === \"string\")\r\n              locales = locales.filter((thisLocale) => !thisError.includes(thisLocale));\r\n          }\r\n        } catch (e) {\r\n          locales = [];\r\n        }\r\n        // if we removed every locale from the array, it wasn't loaded.\r\n        if (locales.length === 0)\r\n          Logger.logError(\"i18n\", `No resources for namespace ${name} could be loaded`);\r\n\r\n        resolve();\r\n      });\r\n    });\r\n    this._namespaces.set(name, theReadPromise);\r\n    return theReadPromise;\r\n  }\r\n\r\n  /** @internal */\r\n  public unregisterNamespace(name: string): void {\r\n    this._namespaces.delete(name);\r\n  }\r\n}\r\n\r\nclass TranslationLogger {\r\n  public static readonly type = \"logger\";\r\n  public log(args: string[]) { Logger.logInfo(\"i18n\", this.createLogMessage(args)); }\r\n  public warn(args: string[]) { Logger.logWarning(\"i18n\", this.createLogMessage(args)); }\r\n  public error(args: string[]) { Logger.logError(\"i18n\", this.createLogMessage(args)); }\r\n  private createLogMessage(args: string[]) {\r\n    let message = args[0];\r\n    for (let i = 1; i < args.length; ++i) {\r\n      if (typeof args[i] === \"string\")\r\n        message += `\\n  ${args[i]}`;\r\n    }\r\n    return message;\r\n  }\r\n}\r\n"]
     },
     _coverageSchema: "1a1c01bbd47fc00a2c39e90264f33305004495a9",
-    hash: "792cee55a98eb07529fe29275d9b77f39664df54"
+    hash: "24e58bea480e0876d4033d5608415d9c06c3e4a5"
   };
   var coverage = global[gcv] || (global[gcv] = {});
   if (!coverage[path] || coverage[path].hash !== hash) {
@@ -3101,57 +3101,57 @@ function cov_a3gxtmyvj() {
   var actualCoverage = coverage[path];
   {
     // @ts-ignore
-    cov_a3gxtmyvj = function () {
+    cov_2l9mmpbx71 = function () {
       return actualCoverage;
     };
   }
   return actualCoverage;
 }
-cov_a3gxtmyvj();
-var __importDefault = (cov_a3gxtmyvj().s[0]++, (cov_a3gxtmyvj().b[0][0]++, this) && (cov_a3gxtmyvj().b[0][1]++, this.__importDefault) || (cov_a3gxtmyvj().b[0][2]++, function (mod) {
-  cov_a3gxtmyvj().f[0]++;
-  cov_a3gxtmyvj().s[1]++;
-  return (cov_a3gxtmyvj().b[2][0]++, mod) && (cov_a3gxtmyvj().b[2][1]++, mod.__esModule) ? (cov_a3gxtmyvj().b[1][0]++, mod) : (cov_a3gxtmyvj().b[1][1]++, {
+cov_2l9mmpbx71();
+var __importDefault = (cov_2l9mmpbx71().s[0]++, (cov_2l9mmpbx71().b[0][0]++, this) && (cov_2l9mmpbx71().b[0][1]++, this.__importDefault) || (cov_2l9mmpbx71().b[0][2]++, function (mod) {
+  cov_2l9mmpbx71().f[0]++;
+  cov_2l9mmpbx71().s[1]++;
+  return (cov_2l9mmpbx71().b[2][0]++, mod) && (cov_2l9mmpbx71().b[2][1]++, mod.__esModule) ? (cov_2l9mmpbx71().b[1][0]++, mod) : (cov_2l9mmpbx71().b[1][1]++, {
     "default": mod
   });
 }));
-cov_a3gxtmyvj().s[2]++;
+cov_2l9mmpbx71().s[2]++;
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-cov_a3gxtmyvj().s[3]++;
+cov_2l9mmpbx71().s[3]++;
 exports.ITwinLocalization = void 0;
-const i18next_1 = (cov_a3gxtmyvj().s[4]++, __importDefault(__webpack_require__(/*! i18next */ "../../common/temp/node_modules/.pnpm/i18next@21.10.0/node_modules/i18next/dist/cjs/i18next.js")));
-const i18next_browser_languagedetector_1 = (cov_a3gxtmyvj().s[5]++, __importDefault(__webpack_require__(/*! i18next-browser-languagedetector */ "../../common/temp/node_modules/.pnpm/i18next-browser-languagedetector@6.1.8/node_modules/i18next-browser-languagedetector/dist/cjs/i18nextBrowserLanguageDetector.js")));
-const i18next_http_backend_1 = (cov_a3gxtmyvj().s[6]++, __importDefault(__webpack_require__(/*! i18next-http-backend */ "../../common/temp/node_modules/.pnpm/i18next-http-backend@1.4.5/node_modules/i18next-http-backend/cjs/index.js")));
-const core_bentley_1 = (cov_a3gxtmyvj().s[7]++, __webpack_require__(/*! @itwin/core-bentley */ "../bentley/lib/esm/core-bentley.js"));
-const DEFAULT_MAX_RETRIES = (cov_a3gxtmyvj().s[8]++, 1); // a low number prevents wasted time and potential timeouts when requesting localization files throws an error
-/** Supplies localizations for iTwin.js
- * @note this class uses the [i18next](https://www.i18next.com/) package.
- * @public
+const i18next_1 = (cov_2l9mmpbx71().s[4]++, __importDefault(__webpack_require__(/*! i18next */ "../../common/temp/node_modules/.pnpm/i18next@21.10.0/node_modules/i18next/dist/cjs/i18next.js")));
+const i18next_browser_languagedetector_1 = (cov_2l9mmpbx71().s[5]++, __importDefault(__webpack_require__(/*! i18next-browser-languagedetector */ "../../common/temp/node_modules/.pnpm/i18next-browser-languagedetector@6.1.8/node_modules/i18next-browser-languagedetector/dist/cjs/i18nextBrowserLanguageDetector.js")));
+const i18next_http_backend_1 = (cov_2l9mmpbx71().s[6]++, __importDefault(__webpack_require__(/*! i18next-http-backend */ "../../common/temp/node_modules/.pnpm/i18next-http-backend@1.4.5/node_modules/i18next-http-backend/cjs/index.js")));
+const core_bentley_1 = (cov_2l9mmpbx71().s[7]++, __webpack_require__(/*! @itwin/core-bentley */ "../bentley/lib/esm/core-bentley.js"));
+const DEFAULT_MAX_RETRIES = (cov_2l9mmpbx71().s[8]++, 1); // a low number prevents wasted time and potential timeouts when requesting localization files throws an error
+/** Supplies localizations for iTwin.js
+ * @note this class uses the [i18next](https://www.i18next.com/) package.
+ * @public
  */
 class ITwinLocalization {
   constructor(options) {
-    cov_a3gxtmyvj().f[1]++;
+    cov_2l9mmpbx71().f[1]++;
     var _a, _b, _c;
-    cov_a3gxtmyvj().s[9]++;
+    cov_2l9mmpbx71().s[9]++;
     this._namespaces = new Map();
-    cov_a3gxtmyvj().s[10]++;
+    cov_2l9mmpbx71().s[10]++;
     this.i18next = i18next_1.default.createInstance();
-    cov_a3gxtmyvj().s[11]++;
+    cov_2l9mmpbx71().s[11]++;
     this._backendOptions = {
-      loadPath: (cov_a3gxtmyvj().b[4][0]++, (_a = (cov_a3gxtmyvj().b[6][0]++, options === null) || (cov_a3gxtmyvj().b[6][1]++, options === void 0) ? (cov_a3gxtmyvj().b[5][0]++, void 0) : (cov_a3gxtmyvj().b[5][1]++, options.urlTemplate)) !== null) && (cov_a3gxtmyvj().b[4][1]++, _a !== void 0) ? (cov_a3gxtmyvj().b[3][0]++, _a) : (cov_a3gxtmyvj().b[3][1]++, "locales/{{lng}}/{{ns}}.json"),
+      loadPath: (cov_2l9mmpbx71().b[4][0]++, (_a = (cov_2l9mmpbx71().b[6][0]++, options === null) || (cov_2l9mmpbx71().b[6][1]++, options === void 0) ? (cov_2l9mmpbx71().b[5][0]++, void 0) : (cov_2l9mmpbx71().b[5][1]++, options.urlTemplate)) !== null) && (cov_2l9mmpbx71().b[4][1]++, _a !== void 0) ? (cov_2l9mmpbx71().b[3][0]++, _a) : (cov_2l9mmpbx71().b[3][1]++, "locales/{{lng}}/{{ns}}.json"),
       crossDomain: true,
-      ...((cov_a3gxtmyvj().b[8][0]++, options === null) || (cov_a3gxtmyvj().b[8][1]++, options === void 0) ? (cov_a3gxtmyvj().b[7][0]++, void 0) : (cov_a3gxtmyvj().b[7][1]++, options.backendHttpOptions))
+      ...((cov_2l9mmpbx71().b[8][0]++, options === null) || (cov_2l9mmpbx71().b[8][1]++, options === void 0) ? (cov_2l9mmpbx71().b[7][0]++, void 0) : (cov_2l9mmpbx71().b[7][1]++, options.backendHttpOptions))
     };
-    cov_a3gxtmyvj().s[12]++;
+    cov_2l9mmpbx71().s[12]++;
     this._detectionOptions = {
       order: ["querystring", "navigator", "htmlTag"],
       lookupQuerystring: "lng",
       caches: [],
-      ...((cov_a3gxtmyvj().b[10][0]++, options === null) || (cov_a3gxtmyvj().b[10][1]++, options === void 0) ? (cov_a3gxtmyvj().b[9][0]++, void 0) : (cov_a3gxtmyvj().b[9][1]++, options.detectorOptions))
+      ...((cov_2l9mmpbx71().b[10][0]++, options === null) || (cov_2l9mmpbx71().b[10][1]++, options === void 0) ? (cov_2l9mmpbx71().b[9][0]++, void 0) : (cov_2l9mmpbx71().b[9][1]++, options.detectorOptions))
     };
-    cov_a3gxtmyvj().s[13]++;
+    cov_2l9mmpbx71().s[13]++;
     this._initOptions = {
       interpolation: {
         escapeValue: true
@@ -3160,316 +3160,316 @@ class ITwinLocalization {
       maxRetries: DEFAULT_MAX_RETRIES,
       backend: this._backendOptions,
       detection: this._detectionOptions,
-      ...((cov_a3gxtmyvj().b[12][0]++, options === null) || (cov_a3gxtmyvj().b[12][1]++, options === void 0) ? (cov_a3gxtmyvj().b[11][0]++, void 0) : (cov_a3gxtmyvj().b[11][1]++, options.initOptions))
+      ...((cov_2l9mmpbx71().b[12][0]++, options === null) || (cov_2l9mmpbx71().b[12][1]++, options === void 0) ? (cov_2l9mmpbx71().b[11][0]++, void 0) : (cov_2l9mmpbx71().b[11][1]++, options.initOptions))
     };
-    cov_a3gxtmyvj().s[14]++;
-    this.i18next.use((cov_a3gxtmyvj().b[14][0]++, (_b = (cov_a3gxtmyvj().b[16][0]++, options === null) || (cov_a3gxtmyvj().b[16][1]++, options === void 0) ? (cov_a3gxtmyvj().b[15][0]++, void 0) : (cov_a3gxtmyvj().b[15][1]++, options.detectorPlugin)) !== null) && (cov_a3gxtmyvj().b[14][1]++, _b !== void 0) ? (cov_a3gxtmyvj().b[13][0]++, _b) : (cov_a3gxtmyvj().b[13][1]++, i18next_browser_languagedetector_1.default)).use((cov_a3gxtmyvj().b[18][0]++, (_c = (cov_a3gxtmyvj().b[20][0]++, options === null) || (cov_a3gxtmyvj().b[20][1]++, options === void 0) ? (cov_a3gxtmyvj().b[19][0]++, void 0) : (cov_a3gxtmyvj().b[19][1]++, options.backendPlugin)) !== null) && (cov_a3gxtmyvj().b[18][1]++, _c !== void 0) ? (cov_a3gxtmyvj().b[17][0]++, _c) : (cov_a3gxtmyvj().b[17][1]++, i18next_http_backend_1.default)).use(TranslationLogger);
+    cov_2l9mmpbx71().s[14]++;
+    this.i18next.use((cov_2l9mmpbx71().b[14][0]++, (_b = (cov_2l9mmpbx71().b[16][0]++, options === null) || (cov_2l9mmpbx71().b[16][1]++, options === void 0) ? (cov_2l9mmpbx71().b[15][0]++, void 0) : (cov_2l9mmpbx71().b[15][1]++, options.detectorPlugin)) !== null) && (cov_2l9mmpbx71().b[14][1]++, _b !== void 0) ? (cov_2l9mmpbx71().b[13][0]++, _b) : (cov_2l9mmpbx71().b[13][1]++, i18next_browser_languagedetector_1.default)).use((cov_2l9mmpbx71().b[18][0]++, (_c = (cov_2l9mmpbx71().b[20][0]++, options === null) || (cov_2l9mmpbx71().b[20][1]++, options === void 0) ? (cov_2l9mmpbx71().b[19][0]++, void 0) : (cov_2l9mmpbx71().b[19][1]++, options.backendPlugin)) !== null) && (cov_2l9mmpbx71().b[18][1]++, _c !== void 0) ? (cov_2l9mmpbx71().b[17][0]++, _c) : (cov_2l9mmpbx71().b[17][1]++, i18next_http_backend_1.default)).use(TranslationLogger);
   }
   async initialize(namespaces) {
-    cov_a3gxtmyvj().f[2]++;
+    cov_2l9mmpbx71().f[2]++;
     var _a;
     // Also consider namespaces passed into constructor
-    const initNamespaces = (cov_a3gxtmyvj().s[15]++, [(cov_a3gxtmyvj().b[21][0]++, this._initOptions.ns) || (cov_a3gxtmyvj().b[21][1]++, [])].flat());
-    const combinedNamespaces = (cov_a3gxtmyvj().s[16]++, new Set([...namespaces, ...initNamespaces])); // without duplicates
-    const defaultNamespace = (cov_a3gxtmyvj().s[17]++, (cov_a3gxtmyvj().b[23][0]++, (_a = this._initOptions.defaultNS) !== null) && (cov_a3gxtmyvj().b[23][1]++, _a !== void 0) ? (cov_a3gxtmyvj().b[22][0]++, _a) : (cov_a3gxtmyvj().b[22][1]++, namespaces[0]));
-    cov_a3gxtmyvj().s[18]++;
+    const initNamespaces = (cov_2l9mmpbx71().s[15]++, [(cov_2l9mmpbx71().b[21][0]++, this._initOptions.ns) || (cov_2l9mmpbx71().b[21][1]++, [])].flat());
+    const combinedNamespaces = (cov_2l9mmpbx71().s[16]++, new Set([...namespaces, ...initNamespaces])); // without duplicates
+    const defaultNamespace = (cov_2l9mmpbx71().s[17]++, (cov_2l9mmpbx71().b[23][0]++, (_a = this._initOptions.defaultNS) !== null) && (cov_2l9mmpbx71().b[23][1]++, _a !== void 0) ? (cov_2l9mmpbx71().b[22][0]++, _a) : (cov_2l9mmpbx71().b[22][1]++, namespaces[0]));
+    cov_2l9mmpbx71().s[18]++;
     if (defaultNamespace) {
-      cov_a3gxtmyvj().b[24][0]++;
-      cov_a3gxtmyvj().s[19]++;
+      cov_2l9mmpbx71().b[24][0]++;
+      cov_2l9mmpbx71().s[19]++;
       combinedNamespaces.add(defaultNamespace);
     } else {
-      cov_a3gxtmyvj().b[24][1]++;
+      cov_2l9mmpbx71().b[24][1]++;
     } // Make sure default namespace is in namespaces list
-    const initOptions = (cov_a3gxtmyvj().s[20]++, {
+    const initOptions = (cov_2l9mmpbx71().s[20]++, {
       ...this._initOptions,
       defaultNS: defaultNamespace,
       ns: [...combinedNamespaces]
     });
     // if in a development environment, set debugging
-    cov_a3gxtmyvj().s[21]++;
+    cov_2l9mmpbx71().s[21]++;
     if (false) {} else {
-      cov_a3gxtmyvj().b[25][1]++;
+      cov_2l9mmpbx71().b[25][1]++;
     }
-    const initPromise = (cov_a3gxtmyvj().s[23]++, this.i18next.init(initOptions));
-    cov_a3gxtmyvj().s[24]++;
+    const initPromise = (cov_2l9mmpbx71().s[23]++, this.i18next.init(initOptions));
+    cov_2l9mmpbx71().s[24]++;
     for (const ns of namespaces) {
-      cov_a3gxtmyvj().s[25]++;
+      cov_2l9mmpbx71().s[25]++;
       this._namespaces.set(ns, initPromise);
     }
-    cov_a3gxtmyvj().s[26]++;
+    cov_2l9mmpbx71().s[26]++;
     return initPromise;
   }
-  /** Replace all instances of `%{key}` within a string with the translations of those keys.
-   * For example:
-   * ``` ts
-   * "MyKeys": {
-   *   "Key1": "First value",
-   *   "Key2": "Second value"
-   *  }
-   * ```
-   *
-   * ``` ts
-   * i18.translateKeys("string with %{MyKeys.Key1} followed by %{MyKeys.Key2}!"") // returns "string with First Value followed by Second Value!"
-   * ```
-   * @param line The input line, potentially containing %{keys}.
-   * @returns The line with all %{keys} translated
-   * @public
+  /** Replace all instances of `%{key}` within a string with the translations of those keys.
+   * For example:
+   * ``` ts
+   * "MyKeys": {
+   *   "Key1": "First value",
+   *   "Key2": "Second value"
+   *  }
+   * ```
+   *
+   * ``` ts
+   * i18.translateKeys("string with %{MyKeys.Key1} followed by %{MyKeys.Key2}!"") // returns "string with First Value followed by Second Value!"
+   * ```
+   * @param line The input line, potentially containing %{keys}.
+   * @returns The line with all %{keys} translated
+   * @public
    */
   getLocalizedKeys(line) {
-    cov_a3gxtmyvj().f[3]++;
-    cov_a3gxtmyvj().s[27]++;
+    cov_2l9mmpbx71().f[3]++;
+    cov_2l9mmpbx71().s[27]++;
     return line.replace(/\%\{(.+?)\}/g, (_match, tag) => {
-      cov_a3gxtmyvj().f[4]++;
-      cov_a3gxtmyvj().s[28]++;
+      cov_2l9mmpbx71().f[4]++;
+      cov_2l9mmpbx71().s[28]++;
       return this.getLocalizedString(tag);
     });
   }
-  /** Return the translated value of a key.
-   * @param key - the key that matches a property in the JSON localization file.
-   * @note The key includes the namespace, which identifies the particular localization file that contains the property,
-   * followed by a colon, followed by the property in the JSON file.
-   * For example:
-   * ``` ts
-   * const dataString: string = IModelApp.localization.getLocalizedString("iModelJs:BackgroundMap.BingDataAttribution");
-   *  ```
-   * assigns to dataString the string with property BackgroundMap.BingDataAttribution from the iModelJs.json localization file.
-   * @returns The string corresponding to the first key that resolves.
-   * @throws Error if no keys resolve to a string.
-   * @public
+  /** Return the translated value of a key.
+   * @param key - the key that matches a property in the JSON localization file.
+   * @note The key includes the namespace, which identifies the particular localization file that contains the property,
+   * followed by a colon, followed by the property in the JSON file.
+   * For example:
+   * ``` ts
+   * const dataString: string = IModelApp.localization.getLocalizedString("iModelJs:BackgroundMap.BingDataAttribution");
+   *  ```
+   * assigns to dataString the string with property BackgroundMap.BingDataAttribution from the iModelJs.json localization file.
+   * @returns The string corresponding to the first key that resolves.
+   * @throws Error if no keys resolve to a string.
+   * @public
    */
   getLocalizedString(key, options) {
-    cov_a3gxtmyvj().f[5]++;
-    cov_a3gxtmyvj().s[29]++;
-    if ((cov_a3gxtmyvj().b[27][0]++, (cov_a3gxtmyvj().b[29][0]++, options === null) || (cov_a3gxtmyvj().b[29][1]++, options === void 0) ? (cov_a3gxtmyvj().b[28][0]++, void 0) : (cov_a3gxtmyvj().b[28][1]++, options.returnDetails)) || (cov_a3gxtmyvj().b[27][1]++, (cov_a3gxtmyvj().b[31][0]++, options === null) || (cov_a3gxtmyvj().b[31][1]++, options === void 0) ? (cov_a3gxtmyvj().b[30][0]++, void 0) : (cov_a3gxtmyvj().b[30][1]++, options.returnObjects))) {
-      cov_a3gxtmyvj().b[26][0]++;
-      cov_a3gxtmyvj().s[30]++;
+    cov_2l9mmpbx71().f[5]++;
+    cov_2l9mmpbx71().s[29]++;
+    if ((cov_2l9mmpbx71().b[27][0]++, (cov_2l9mmpbx71().b[29][0]++, options === null) || (cov_2l9mmpbx71().b[29][1]++, options === void 0) ? (cov_2l9mmpbx71().b[28][0]++, void 0) : (cov_2l9mmpbx71().b[28][1]++, options.returnDetails)) || (cov_2l9mmpbx71().b[27][1]++, (cov_2l9mmpbx71().b[31][0]++, options === null) || (cov_2l9mmpbx71().b[31][1]++, options === void 0) ? (cov_2l9mmpbx71().b[30][0]++, void 0) : (cov_2l9mmpbx71().b[30][1]++, options.returnObjects))) {
+      cov_2l9mmpbx71().b[26][0]++;
+      cov_2l9mmpbx71().s[30]++;
       throw new Error("Translation key must map to a string, but the given options will result in an object");
     } else {
-      cov_a3gxtmyvj().b[26][1]++;
+      cov_2l9mmpbx71().b[26][1]++;
     }
-    const value = (cov_a3gxtmyvj().s[31]++, this.i18next.t(key, options));
-    cov_a3gxtmyvj().s[32]++;
+    const value = (cov_2l9mmpbx71().s[31]++, this.i18next.t(key, options));
+    cov_2l9mmpbx71().s[32]++;
     if (typeof value !== "string") {
-      cov_a3gxtmyvj().b[32][0]++;
-      cov_a3gxtmyvj().s[33]++;
+      cov_2l9mmpbx71().b[32][0]++;
+      cov_2l9mmpbx71().s[33]++;
       throw new Error("Translation key(s) string not found");
     } else {
-      cov_a3gxtmyvj().b[32][1]++;
+      cov_2l9mmpbx71().b[32][1]++;
     }
-    cov_a3gxtmyvj().s[34]++;
+    cov_2l9mmpbx71().s[34]++;
     return value;
   }
-  /** Similar to `getLocalizedString` but the default namespace is a separate parameter and the key does not need
-   * to include a namespace. If a key includes a namespace, that namespace will be used for interpolating that key.
-   * @param namespace - the namespace that identifies the particular localization file that contains the property.
-   * @param key - the key that matches a property in the JSON localization file.
-   * @returns The string corresponding to the first key that resolves.
-   * @throws Error if no keys resolve to a string.
-   * @internal
+  /** Similar to `getLocalizedString` but the default namespace is a separate parameter and the key does not need
+   * to include a namespace. If a key includes a namespace, that namespace will be used for interpolating that key.
+   * @param namespace - the namespace that identifies the particular localization file that contains the property.
+   * @param key - the key that matches a property in the JSON localization file.
+   * @returns The string corresponding to the first key that resolves.
+   * @throws Error if no keys resolve to a string.
+   * @internal
    */
   getLocalizedStringWithNamespace(namespace, key, options) {
-    cov_a3gxtmyvj().f[6]++;
-    let fullKey = (cov_a3gxtmyvj().s[35]++, "");
-    cov_a3gxtmyvj().s[36]++;
+    cov_2l9mmpbx71().f[6]++;
+    let fullKey = (cov_2l9mmpbx71().s[35]++, "");
+    cov_2l9mmpbx71().s[36]++;
     if (typeof key === "string") {
-      cov_a3gxtmyvj().b[33][0]++;
-      cov_a3gxtmyvj().s[37]++;
+      cov_2l9mmpbx71().b[33][0]++;
+      cov_2l9mmpbx71().s[37]++;
       fullKey = `${namespace}:${key}`;
     } else {
-      cov_a3gxtmyvj().b[33][1]++;
-      cov_a3gxtmyvj().s[38]++;
+      cov_2l9mmpbx71().b[33][1]++;
+      cov_2l9mmpbx71().s[38]++;
       fullKey = key.map(subKey => {
-        cov_a3gxtmyvj().f[7]++;
-        cov_a3gxtmyvj().s[39]++;
+        cov_2l9mmpbx71().f[7]++;
+        cov_2l9mmpbx71().s[39]++;
         return `${namespace}:${subKey}`;
       });
     }
-    cov_a3gxtmyvj().s[40]++;
+    cov_2l9mmpbx71().s[40]++;
     return this.getLocalizedString(fullKey, options);
   }
-  /** Gets the English translation.
-   * @param namespace - the namespace that identifies the particular localization file that contains the property.
-   * @param key - the key that matches a property in the JSON localization file.
-   * @returns The string corresponding to the first key that resolves.
-   * @throws Error if no keys resolve to a string.
-   * @internal
+  /** Gets the English translation.
+   * @param namespace - the namespace that identifies the particular localization file that contains the property.
+   * @param key - the key that matches a property in the JSON localization file.
+   * @returns The string corresponding to the first key that resolves.
+   * @throws Error if no keys resolve to a string.
+   * @internal
    */
   getEnglishString(namespace, key, options) {
-    cov_a3gxtmyvj().f[8]++;
-    cov_a3gxtmyvj().s[41]++;
-    if ((cov_a3gxtmyvj().b[35][0]++, (cov_a3gxtmyvj().b[37][0]++, options === null) || (cov_a3gxtmyvj().b[37][1]++, options === void 0) ? (cov_a3gxtmyvj().b[36][0]++, void 0) : (cov_a3gxtmyvj().b[36][1]++, options.returnDetails)) || (cov_a3gxtmyvj().b[35][1]++, (cov_a3gxtmyvj().b[39][0]++, options === null) || (cov_a3gxtmyvj().b[39][1]++, options === void 0) ? (cov_a3gxtmyvj().b[38][0]++, void 0) : (cov_a3gxtmyvj().b[38][1]++, options.returnObjects))) {
-      cov_a3gxtmyvj().b[34][0]++;
-      cov_a3gxtmyvj().s[42]++;
+    cov_2l9mmpbx71().f[8]++;
+    cov_2l9mmpbx71().s[41]++;
+    if ((cov_2l9mmpbx71().b[35][0]++, (cov_2l9mmpbx71().b[37][0]++, options === null) || (cov_2l9mmpbx71().b[37][1]++, options === void 0) ? (cov_2l9mmpbx71().b[36][0]++, void 0) : (cov_2l9mmpbx71().b[36][1]++, options.returnDetails)) || (cov_2l9mmpbx71().b[35][1]++, (cov_2l9mmpbx71().b[39][0]++, options === null) || (cov_2l9mmpbx71().b[39][1]++, options === void 0) ? (cov_2l9mmpbx71().b[38][0]++, void 0) : (cov_2l9mmpbx71().b[38][1]++, options.returnObjects))) {
+      cov_2l9mmpbx71().b[34][0]++;
+      cov_2l9mmpbx71().s[42]++;
       throw new Error("Translation key must map to a string, but the given options will result in an object");
     } else {
-      cov_a3gxtmyvj().b[34][1]++;
+      cov_2l9mmpbx71().b[34][1]++;
     }
-    cov_a3gxtmyvj().s[43]++;
+    cov_2l9mmpbx71().s[43]++;
     options = {
       ...options,
       ns: namespace // ensure namespace argument is used
     };
 
-    const en = (cov_a3gxtmyvj().s[44]++, this.i18next.getFixedT("en", namespace));
-    const str = (cov_a3gxtmyvj().s[45]++, en(key, options));
-    cov_a3gxtmyvj().s[46]++;
+    const en = (cov_2l9mmpbx71().s[44]++, this.i18next.getFixedT("en", namespace));
+    const str = (cov_2l9mmpbx71().s[45]++, en(key, options));
+    cov_2l9mmpbx71().s[46]++;
     if (typeof str !== "string") {
-      cov_a3gxtmyvj().b[40][0]++;
-      cov_a3gxtmyvj().s[47]++;
+      cov_2l9mmpbx71().b[40][0]++;
+      cov_2l9mmpbx71().s[47]++;
       throw new Error("Translation key(s) not found");
     } else {
-      cov_a3gxtmyvj().b[40][1]++;
+      cov_2l9mmpbx71().b[40][1]++;
     }
-    cov_a3gxtmyvj().s[48]++;
+    cov_2l9mmpbx71().s[48]++;
     return str;
   }
-  /** Get the promise for an already registered Namespace.
-   * @param name - the name of the namespace
-   * @public
+  /** Get the promise for an already registered Namespace.
+   * @param name - the name of the namespace
+   * @public
    */
   getNamespacePromise(name) {
-    cov_a3gxtmyvj().f[9]++;
-    cov_a3gxtmyvj().s[49]++;
+    cov_2l9mmpbx71().f[9]++;
+    cov_2l9mmpbx71().s[49]++;
     return this._namespaces.get(name);
   }
   /** @internal */
   getLanguageList() {
-    cov_a3gxtmyvj().f[10]++;
-    cov_a3gxtmyvj().s[50]++;
+    cov_2l9mmpbx71().f[10]++;
+    cov_2l9mmpbx71().s[50]++;
     return this.i18next.languages;
   }
   /** override the language detected in the browser  */
   async changeLanguage(language) {
-    cov_a3gxtmyvj().f[11]++;
-    cov_a3gxtmyvj().s[51]++;
+    cov_2l9mmpbx71().f[11]++;
+    cov_2l9mmpbx71().s[51]++;
     return this.i18next.changeLanguage(language);
   }
-  /** Register a new Namespace and return it. If the namespace is already registered, it will be returned.
-   * @param name - the name of the namespace, which is the base name of the JSON file that contains the localization properties.
-   * @note - The registerNamespace method starts fetching the appropriate version of the JSON localization file from the server,
-   * based on the current locale. To make sure that fetch is complete before performing translations from this namespace, await
-   * fulfillment of the readPromise Promise property of the returned LocalizationNamespace.
-   * @see [Localization in iTwin.js]($docs/learning/frontend/Localization.md)
-   * @public
+  /** Register a new Namespace and return it. If the namespace is already registered, it will be returned.
+   * @param name - the name of the namespace, which is the base name of the JSON file that contains the localization properties.
+   * @note - The registerNamespace method starts fetching the appropriate version of the JSON localization file from the server,
+   * based on the current locale. To make sure that fetch is complete before performing translations from this namespace, await
+   * fulfillment of the readPromise Promise property of the returned LocalizationNamespace.
+   * @see [Localization in iTwin.js]($docs/learning/frontend/Localization.md)
+   * @public
    */
   async registerNamespace(name) {
-    cov_a3gxtmyvj().f[12]++;
-    const existing = (cov_a3gxtmyvj().s[52]++, this._namespaces.get(name));
-    cov_a3gxtmyvj().s[53]++;
+    cov_2l9mmpbx71().f[12]++;
+    const existing = (cov_2l9mmpbx71().s[52]++, this._namespaces.get(name));
+    cov_2l9mmpbx71().s[53]++;
     if (existing !== undefined) {
-      cov_a3gxtmyvj().b[41][0]++;
-      cov_a3gxtmyvj().s[54]++;
+      cov_2l9mmpbx71().b[41][0]++;
+      cov_2l9mmpbx71().s[54]++;
       return existing;
     } else {
-      cov_a3gxtmyvj().b[41][1]++;
+      cov_2l9mmpbx71().b[41][1]++;
     }
-    const theReadPromise = (cov_a3gxtmyvj().s[55]++, new Promise(resolve => {
-      cov_a3gxtmyvj().f[13]++;
-      cov_a3gxtmyvj().s[56]++;
+    const theReadPromise = (cov_2l9mmpbx71().s[55]++, new Promise(resolve => {
+      cov_2l9mmpbx71().f[13]++;
+      cov_2l9mmpbx71().s[56]++;
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
       this.i18next.loadNamespaces(name, err => {
-        cov_a3gxtmyvj().f[14]++;
-        cov_a3gxtmyvj().s[57]++;
+        cov_2l9mmpbx71().f[14]++;
+        cov_2l9mmpbx71().s[57]++;
         if (!err) {
-          cov_a3gxtmyvj().b[42][0]++;
-          cov_a3gxtmyvj().s[58]++;
+          cov_2l9mmpbx71().b[42][0]++;
+          cov_2l9mmpbx71().s[58]++;
           return resolve();
         } else {
-          cov_a3gxtmyvj().b[42][1]++;
+          cov_2l9mmpbx71().b[42][1]++;
         }
         // Here we got a non-null err object.
         // This method is called when the system has attempted to load the resources for the namespaces for each possible locale.
         // For example 'fr-ca' might be the most specific locale, in which case 'fr' and 'en' are fallback locales.
         // Using Backend from i18next-http-backend, err will be an array of strings of each namespace it tried to read and its locale.
         // There might be errs for some other namespaces as well as this one. We resolve the promise unless there's an error for each possible locale.
-        let locales = (cov_a3gxtmyvj().s[59]++, this.getLanguageList().map(thisLocale => {
-          cov_a3gxtmyvj().f[15]++;
-          cov_a3gxtmyvj().s[60]++;
+        let locales = (cov_2l9mmpbx71().s[59]++, this.getLanguageList().map(thisLocale => {
+          cov_2l9mmpbx71().f[15]++;
+          cov_2l9mmpbx71().s[60]++;
           return `/${thisLocale}/`;
         }));
-        cov_a3gxtmyvj().s[61]++;
+        cov_2l9mmpbx71().s[61]++;
         try {
-          cov_a3gxtmyvj().s[62]++;
+          cov_2l9mmpbx71().s[62]++;
           for (const thisError of err) {
-            cov_a3gxtmyvj().s[63]++;
+            cov_2l9mmpbx71().s[63]++;
             if (typeof thisError === "string") {
-              cov_a3gxtmyvj().b[43][0]++;
-              cov_a3gxtmyvj().s[64]++;
+              cov_2l9mmpbx71().b[43][0]++;
+              cov_2l9mmpbx71().s[64]++;
               locales = locales.filter(thisLocale => {
-                cov_a3gxtmyvj().f[16]++;
-                cov_a3gxtmyvj().s[65]++;
+                cov_2l9mmpbx71().f[16]++;
+                cov_2l9mmpbx71().s[65]++;
                 return !thisError.includes(thisLocale);
               });
             } else {
-              cov_a3gxtmyvj().b[43][1]++;
+              cov_2l9mmpbx71().b[43][1]++;
             }
           }
         } catch (e) {
-          cov_a3gxtmyvj().s[66]++;
+          cov_2l9mmpbx71().s[66]++;
           locales = [];
         }
         // if we removed every locale from the array, it wasn't loaded.
-        cov_a3gxtmyvj().s[67]++;
+        cov_2l9mmpbx71().s[67]++;
         if (locales.length === 0) {
-          cov_a3gxtmyvj().b[44][0]++;
-          cov_a3gxtmyvj().s[68]++;
+          cov_2l9mmpbx71().b[44][0]++;
+          cov_2l9mmpbx71().s[68]++;
           core_bentley_1.Logger.logError("i18n", `No resources for namespace ${name} could be loaded`);
         } else {
-          cov_a3gxtmyvj().b[44][1]++;
+          cov_2l9mmpbx71().b[44][1]++;
         }
-        cov_a3gxtmyvj().s[69]++;
+        cov_2l9mmpbx71().s[69]++;
         resolve();
       });
     }));
-    cov_a3gxtmyvj().s[70]++;
+    cov_2l9mmpbx71().s[70]++;
     this._namespaces.set(name, theReadPromise);
-    cov_a3gxtmyvj().s[71]++;
+    cov_2l9mmpbx71().s[71]++;
     return theReadPromise;
   }
   /** @internal */
   unregisterNamespace(name) {
-    cov_a3gxtmyvj().f[17]++;
-    cov_a3gxtmyvj().s[72]++;
+    cov_2l9mmpbx71().f[17]++;
+    cov_2l9mmpbx71().s[72]++;
     this._namespaces.delete(name);
   }
 }
-cov_a3gxtmyvj().s[73]++;
+cov_2l9mmpbx71().s[73]++;
 exports.ITwinLocalization = ITwinLocalization;
 class TranslationLogger {
   log(args) {
-    cov_a3gxtmyvj().f[18]++;
-    cov_a3gxtmyvj().s[74]++;
+    cov_2l9mmpbx71().f[18]++;
+    cov_2l9mmpbx71().s[74]++;
     core_bentley_1.Logger.logInfo("i18n", this.createLogMessage(args));
   }
   warn(args) {
-    cov_a3gxtmyvj().f[19]++;
-    cov_a3gxtmyvj().s[75]++;
+    cov_2l9mmpbx71().f[19]++;
+    cov_2l9mmpbx71().s[75]++;
     core_bentley_1.Logger.logWarning("i18n", this.createLogMessage(args));
   }
   error(args) {
-    cov_a3gxtmyvj().f[20]++;
-    cov_a3gxtmyvj().s[76]++;
+    cov_2l9mmpbx71().f[20]++;
+    cov_2l9mmpbx71().s[76]++;
     core_bentley_1.Logger.logError("i18n", this.createLogMessage(args));
   }
   createLogMessage(args) {
-    cov_a3gxtmyvj().f[21]++;
-    let message = (cov_a3gxtmyvj().s[77]++, args[0]);
-    cov_a3gxtmyvj().s[78]++;
-    for (let i = (cov_a3gxtmyvj().s[79]++, 1); i < args.length; ++i) {
-      cov_a3gxtmyvj().s[80]++;
+    cov_2l9mmpbx71().f[21]++;
+    let message = (cov_2l9mmpbx71().s[77]++, args[0]);
+    cov_2l9mmpbx71().s[78]++;
+    for (let i = (cov_2l9mmpbx71().s[79]++, 1); i < args.length; ++i) {
+      cov_2l9mmpbx71().s[80]++;
       if (typeof args[i] === "string") {
-        cov_a3gxtmyvj().b[45][0]++;
-        cov_a3gxtmyvj().s[81]++;
+        cov_2l9mmpbx71().b[45][0]++;
+        cov_2l9mmpbx71().s[81]++;
         message += `\n  ${args[i]}`;
       } else {
-        cov_a3gxtmyvj().b[45][1]++;
+        cov_2l9mmpbx71().b[45][1]++;
       }
     }
-    cov_a3gxtmyvj().s[82]++;
+    cov_2l9mmpbx71().s[82]++;
     return message;
   }
 }
-cov_a3gxtmyvj().s[83]++;
+cov_2l9mmpbx71().s[83]++;
 TranslationLogger.type = "logger";
 
 /***/ }),
@@ -26630,874 +26630,874 @@ var exports = __webpack_exports__;
 /*!************************************************!*\
   !*** ./lib/cjs/test/ITwinLocalization.test.js ***!
   \************************************************/
-
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-const chai_1 = __webpack_require__(/*! chai */ "../../common/temp/node_modules/.pnpm/chai@4.3.7/node_modules/chai/index.js");
-const ITwinLocalization_1 = __webpack_require__(/*! ../ITwinLocalization */ "./lib/cjs/ITwinLocalization.js");
-describe("ITwinLocalization", () => {
-    let localization;
-    let germanLocalization;
-    describe("#constructor", () => {
-        let itwinLocalization;
-        it("set default namespace", async () => {
-            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default" } });
-            await itwinLocalization.initialize([]);
-            chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
-            chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
-        });
-        it("set default language as english", async () => {
-            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default", lng: "en" } });
-            await itwinLocalization.initialize([]);
-            chai_1.assert.equal(itwinLocalization.i18next.options.lng, "en");
-            chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
-        });
-        it("set default language as NOT english", async () => {
-            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default", lng: "de" } });
-            await itwinLocalization.initialize([]);
-            chai_1.assert.equal(itwinLocalization.i18next.options.lng, "de");
-            chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default german)");
-        });
-        it("set fallback language as NOT english", async () => {
-            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default", fallbackLng: "de" } });
-            await itwinLocalization.initialize([]);
-            chai_1.assert.equal(itwinLocalization.i18next.options.fallbackLng, "de");
-            chai_1.assert.equal(itwinLocalization.getLocalizedString("OnlyGerman"), "Hallo");
-        });
-    });
-    describe("#initialize", () => {
-        let itwinLocalization;
-        it("cannot fetch from unregistered namespaces", async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
-            await localization.initialize([]);
-            chai_1.assert.equal(localization.getEnglishString("Default", "FirstTrivial"), "FirstTrivial");
-            chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial"), "FirstTrivial");
-        });
-        describe("with no default namespace predefined", () => {
-            before(() => {
-                itwinLocalization = new ITwinLocalization_1.ITwinLocalization();
-            });
-            it("no default namespace set when initialized with empty array", async () => {
-                await itwinLocalization.initialize([]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, undefined);
-            });
-            it("initialize with single namespace", async () => {
-                var _a;
-                await itwinLocalization.initialize(["Test"]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Test");
-                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Test"));
-                chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
-            });
-            it("initialize with two namespaces recognizes both namespaces", async () => {
-                var _a, _b;
-                await itwinLocalization.initialize(["Default", "Test"]);
-                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
-                chai_1.assert.isTrue((_b = itwinLocalization.i18next.options.ns) === null || _b === void 0 ? void 0 : _b.includes("Test"));
-                chai_1.assert.equal(itwinLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
-                chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
-            });
-            it("initialize with two namespaces sets first as default", async () => {
-                await itwinLocalization.initialize(["Default", "Test"]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
-                chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
-            });
-            it("initialize with duplicate namespace values does not break anything", async () => {
-                var _a;
-                await itwinLocalization.initialize(["Default", "Default"]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
-                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
-                chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
-                chai_1.assert.equal(itwinLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
-            });
-        });
-        describe("with default namespace", () => {
-            before(() => {
-                itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default" } });
-            });
-            it("default namespace set when initialized with empty array", async () => {
-                await itwinLocalization.initialize([]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
-            });
-            it("default namespace not overridden by one namespace", async () => {
-                await itwinLocalization.initialize(["Test"]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
-            });
-            it("default namespace not overridden by two namespaces", async () => {
-                await itwinLocalization.initialize(["NotExist", "Test"]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
-            });
-            it("duplicate namespace value does not break default namespace", async () => {
-                await itwinLocalization.initialize(["Default"]);
-                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
-            });
-            it("default namespace is in list of all namespaces initalized with empty array", async () => {
-                var _a;
-                await itwinLocalization.initialize([]);
-                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
-            });
-            it("default namespace is in list of all namespaces", async () => {
-                var _a;
-                await itwinLocalization.initialize(["Test"]);
-                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
-            });
-        });
-    });
-    describe("#getLocalizedKeys", () => {
-        before(async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
-            await localization.initialize(["Default", "Test"]);
-            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
-            await germanLocalization.initialize(["Default", "Test"]);
-        });
-        it("no substitution", () => {
-            chai_1.assert.equal(localization.getLocalizedKeys("MyString"), "MyString");
-        });
-        describe("Default Namespace", () => {
-            it("first level string", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{FirstTrivial}"), "hi First level string (default)");
-                chai_1.assert.equal(germanLocalization.getLocalizedKeys("hi %{FirstTrivial}"), "hi First level string (default german)");
-            });
-            it("second level string", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{SecondTrivial.Test1}"), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("bye %{SecondTrivial.Test2}"), "bye Second level string 2 (default)");
-                chai_1.assert.equal(germanLocalization.getLocalizedKeys("%{SecondTrivial.Test1}"), "Second level string 1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedKeys("bye %{SecondTrivial.Test2}"), "bye Second level string 2 (default german)");
-            });
-            it("first level string with keys", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{FirstSubstitution1}"), "First level {{str}} (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("bye %{FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default)");
-                chai_1.assert.equal(germanLocalization.getLocalizedKeys("%{FirstSubstitution1}"), "First level {{str}} (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedKeys("bye %{FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default german)");
-            });
-            it("second level string with keys", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default)");
-                chai_1.assert.equal(germanLocalization.getLocalizedKeys("%{SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedKeys("hi %{SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default german)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("no %{MissingKeyString}"), "no MissingKeyString");
-                chai_1.assert.equal(localization.getLocalizedKeys("no %{MissingKeyString}"), "no MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Given Namespace", () => {
-            it("first level string", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Default:FirstTrivial}"), "hi First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Test:FirstTrivial}"), "hi First level string (test)");
-            });
-            it("second level string", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:SecondTrivial.Test1}"), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Default:SecondTrivial.Test2}"), "bye Second level string 2 (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:SecondTrivial.Test1}"), "Second level string 1 (test)");
-                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Test:SecondTrivial.Test2}"), "bye Second level string 2 (test)");
-            });
-            it("first level string with keys", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:FirstSubstitution1}"), "First level {{str}} (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Default:FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:FirstSubstitution1}"), "First level {{str}} (test)");
-                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Test:FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (test)");
-            });
-            it("second level string with keys", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Default:SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default)");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (test)");
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Test:SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (test)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("no %{Default:MissingKeyString}"), "no MissingKeyString");
-                chai_1.assert.equal(localization.getLocalizedKeys("no %{Test:MissingKeyString}"), "no MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Default:SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
-                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Test:SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Nonexisting Namespace", () => {
-            it("first level fails", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:FirstTrivial}"), "FirstTrivial");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:MissingKeyString}"), "MissingKeyString");
-            });
-            it("second level fails", () => {
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:SecondTrivial.Test1}"), "SecondTrivial.Test1");
-                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:Missing.String}"), "Missing.String");
-            });
-        });
-    });
-    // The goal is not to test i18next's interpolation,
-    // but just to have some simple tests to make sure the
-    // basics work through the ITwinLocalization class.
-    // For interpolation options, see: https://www.i18next.com/translation-function/interpolation
-    describe("#getLocalizedString", () => {
-        before(async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
-            await localization.initialize(["Default", "Test"]);
-            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
-            await germanLocalization.initialize(["Default", "Test"]);
-        });
-        describe("Default Namespace", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)");
-            });
-            it("first level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"]), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstTrivial"]), "First level string (default)");
-            });
-            it("more than two fallback keys succeeds", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist1", "NotExist2"]), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist1", "FirstTrivial", "NotExist2"]), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist1", "NotExist2", "FirstTrivial"]), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["1", "2", "3", "4", "5", "FirstTrivial"]), "First level string (default)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1"), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test2"), "Second level string 2 (default)");
-            });
-            it("second level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (default)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
-            });
-            it("first level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
-            });
-            it("second level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString"), "MissingKeyString");
-            });
-            it("first level missing all keys doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["MissingKeyString", "MissingString2"]), "MissingString2");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.MissingString"), "SecondTrivial.MissingString");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "MissingKeyObject.MissingString"]), "MissingKeyObject.MissingString");
-            });
-            it("read from en-US fallback", () => {
-                chai_1.assert.equal(localization.getLocalizedString("OnlyEnglishUS"), "HelloUS");
-            });
-        });
-        describe("Default Namespace (German)", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstTrivial"), "First level string (default german)");
-            });
-            it("first level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["FirstTrivial", "NotExist"]), "First level string (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstTrivial"]), "First level string (default german)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1"), "Second level string 1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2"), "Second level string 2 (default german)");
-            });
-            it("second level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (default german)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
-            });
-            it("first level with substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
-            });
-            it("second level with substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyString"), "MissingKeyString");
-            });
-            it("first level missing all keys doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["MissingKeyString", "MissingString2"]), "MissingString2");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.MissingString"), "SecondTrivial.MissingString");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Given Namespace", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
-            });
-            it("first level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["Default:FirstTrivial", "Not:NotExist"]), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["Default:NotExist", "Test:FirstTrivial"]), "First level string (test)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:SecondTrivial.Test1"), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Default:SecondTrivial.Test2"), "Second level string 2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test1"), "Second level string 1 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test2"), "Second level string 2 (test)");
-            });
-            it("second level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:SecondTrivial.Test1"]), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["Test:SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Default:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
-            });
-            it("first level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["Test:FirstSubstitution1", "Default:NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Default:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("second level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["Test:SecondSubstitution.Test2", "Default:NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:MissingKeyString"), "MissingKeyString");
-                chai_1.assert.equal(localization.getLocalizedString("Test:MissingKeyString"), "MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.MissingString"), "SecondTrivial.MissingString");
-                chai_1.assert.equal(localization.getLocalizedString("Test:MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
-            });
-            it("read from en-US fallback", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:OnlyEnglishUS"), "HelloUS");
-            });
-        });
-        describe("Given Namespace (German)", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (german)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondTrivial.Test1"), "Second level string 1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondTrivial.Test2"), "Second level string 2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.Test1"), "Second level string 1 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.Test2"), "Second level string 2 (german)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (german)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (german)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:MissingKeyString"), "MissingKeyString");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:MissingKeyString"), "MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.MissingString"), "SecondTrivial.MissingString");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Nonexisting Namespace", () => {
-            it("first level fails", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:FirstTrivial"), "FirstTrivial");
-                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:MissingKeyString"), "MissingKeyString");
-            });
-            it("second level fails", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:SecondTrivial.Test1"), "SecondTrivial.Test1");
-                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:Missing.String"), "Missing.String");
-            });
-            it("fallback key fails", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["Nonexisting:FirstTrivial", "NotExist"]), "NotExist");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "Nonexisting:Missing.String"]), "Missing.String");
-            });
-        });
-        // Test a few options to make sure they get passed through correctly
-        describe("With Options", () => {
-            it("returnDetails throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getLocalizedString("X", { returnDetails: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("returnObjects throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getLocalizedString("X", { returnObjects: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("returnDetails and returnObjects throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getLocalizedString("X", { returnDetails: true, returnObjects: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("default value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Missing", { defaultValue: "default" }), "default");
-            });
-            it("override fallback language", () => {
-                // Doesn't fallback to English
-                chai_1.assert.equal(germanLocalization.getLocalizedString("OnlyEnglish", { fallbackLng: "de" }), "OnlyEnglish");
-            });
-            it("set namespace", () => {
-                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (test)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1", ns: "Test" }), "First level CUSTOM1 (test)");
-            });
-        });
-    });
-    describe("#getLocalizedString with namespace passed in as an option", () => {
-        before(async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
-            await localization.initialize(["Default", "Test"]);
-            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
-            await germanLocalization.initialize(["Default", "Test"]);
-        });
-        describe("Keys Without Namespaces", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Default" }), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (test)");
-            });
-            it("first level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"], { ns: "Default" }), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstTrivial"], { ns: "Test" }), "First level string (test)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Default" }), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test2", { ns: "Default" }), "Second level string 2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test2", { ns: "Test" }), "Second level string 2 (test)");
-            });
-            it("second level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondTrivial.Test1"], { ns: "Default" }), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["SecondTrivial.Test2", "NotExist"], { ns: "Test" }), "Second level string 2 (test)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM2" }), "First level CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution2", { ns: "Default", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM1" }), "First level CUSTOM1 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution2", { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
-            });
-            it("first level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution1"], { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["FirstSubstitution1", "NotExist"], { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution2"], { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("second level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Default" }), "MissingKeyString");
-                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Test" }), "MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.MissingString", { ns: "Test" }), "SecondTrivial.MissingString");
-                chai_1.assert.equal(localization.getLocalizedString("MissingKeyObject.MissingString", { ns: "Test" }), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Keys Without Namespaces (German)", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstTrivial", { ns: "Default" }), "First level string (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (german)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1", { ns: "Default" }), "Second level string 1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2", { ns: "Default" }), "Second level string 2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2", { ns: "Test" }), "Second level string 2 (german)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { ns: "Default", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM1" }), "First level CUSTOM1 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (german)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (german)");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (german)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyString", { ns: "Default" }), "MissingKeyString");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyString", { ns: "Test" }), "MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.MissingString", { ns: "Test" }), "SecondTrivial.MissingString");
-                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyObject.MissingString", { ns: "Test" }), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Keys With Namespaces", () => {
-            it("key with same namespace works", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Default" }), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (test)");
-            });
-            it("key with different namespace overrides given namespace", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial", { ns: "Default" }), "First level string (test)");
-                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Test" }), "First level string (default)");
-            });
-            it("key with same namespace works with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Default:FirstTrivial"], { ns: "Default" }), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Test:FirstTrivial"], { ns: "Test" }), "First level string (test)");
-            });
-            it("key with different namespace overrides given namespace with fallback keys", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Test:FirstTrivial"], { ns: "Default" }), "First level string (test)");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Default:FirstTrivial"], { ns: "Test" }), "First level string (default)");
-            });
-            it("missing key does not find a value", () => {
-                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:MissingKeyString", { ns: "Default" }), "MissingKeyString");
-                chai_1.assert.equal(germanLocalization.getLocalizedString(["Missing1", "MissingKeyObject.MissingString"], { ns: "Test" }), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Nonexisting Namespace", () => {
-            it("first level fails", () => {
-                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Nonexisting" }), "FirstTrivial");
-                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Nonexisting" }), "MissingKeyString");
-            });
-            it("second level fails", () => {
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Nonexisting" }), "SecondTrivial.Test1");
-                chai_1.assert.equal(localization.getLocalizedString("Missing.String", { ns: "Nonexisting" }), "Missing.String");
-            });
-            it("empty string namespace falls back to default namespace", () => {
-                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "" }), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "" }), "Second level string 1 (default)");
-            });
-            it("fallback key fails", () => {
-                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"], { ns: "Nonexisting" }), "NotExist");
-                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "Missing.String"], { ns: "Nonexisting" }), "Missing.String");
-            });
-            it("use key with valid namespace instead", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Nonexisting" }), "First level string (default)");
-                chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial", { ns: "Nonexisting" }), "First level string (test)");
-            });
-            it("providing key with invalid namespace fails", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Nonexisting2:FirstTrivial", { ns: "Nonexisting1" }), "FirstTrivial");
-            });
-        });
-        // Test a few options to make sure they get passed through correctly
-        describe("With Options", () => {
-            it("returnDetails throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getLocalizedString("X", { ns: "Default", returnDetails: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("returnObjects throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getLocalizedString("X", { ns: "Default", returnObjects: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("returnDetails and returnObjects throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getLocalizedString("X", { ns: "Default", returnDetails: true, returnObjects: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("default value", () => {
-                chai_1.assert.equal(localization.getLocalizedString("Missing", { ns: "Default", defaultValue: "default" }), "default");
-            });
-            it("override fallback language", () => {
-                // Doesn't fallback to English
-                chai_1.assert.equal(germanLocalization.getLocalizedString("OnlyEnglish", { ns: "Default", fallbackLng: "de" }), "OnlyEnglish");
-            });
-        });
-    });
-    describe("#getEnglishString", () => {
-        before(async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
-            await localization.initialize(["Default", "Test"]);
-            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
-            await germanLocalization.initialize(["Default", "Test"]);
-        });
-        describe("Given Namespace", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", "FirstTrivial"), "First level string (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "FirstTrivial"), "First level string (test)");
-            });
-            it("first level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", ["FirstTrivial", "NotExist"]), "First level string (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", ["NotExist", "FirstTrivial"]), "First level string (test)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", "SecondTrivial.Test1"), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Default", "SecondTrivial.Test2"), "Second level string 2 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "SecondTrivial.Test1"), "Second level string 1 (test)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "SecondTrivial.Test2"), "Second level string 2 (test)");
-            });
-            it("second level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", ["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", ["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
-            });
-            it("first level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", ["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", ["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(localization.getEnglishString("Test", ["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Default", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
-                chai_1.assert.equal(localization.getEnglishString("Test", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("second level with substitution with fallback keys", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", ["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(localization.getEnglishString("Test", ["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", "MissingKeyString"), "MissingKeyString");
-                chai_1.assert.equal(localization.getEnglishString("Test", "MissingKeyString"), "MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(localization.getEnglishString("Test", "SecondTrivial.MissingString"), "SecondTrivial.MissingString");
-                chai_1.assert.equal(localization.getEnglishString("Test", "MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Given Namespace with German default language returns English strings", () => {
-            it("first level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstTrivial"), "First level string (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstTrivial"), "First level string (test)");
-            });
-            it("first level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["FirstTrivial", "NotExist"]), "First level string (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["NotExist", "FirstTrivial"]), "First level string (test)");
-            });
-            it("second level with no substitution", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondTrivial.Test1"), "Second level string 1 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondTrivial.Test2"), "Second level string 2 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.Test1"), "Second level string 1 (test)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.Test2"), "Second level string 2 (test)");
-            });
-            it("second level with no substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
-            });
-            it("first level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
-            });
-            it("first level with substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
-            });
-            it("second level with substitution", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("second level with substitution with fallback keys", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
-            });
-            it("first level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "MissingKeyString"), "MissingKeyString");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "MissingKeyString"), "MissingKeyString");
-            });
-            it("second level missing key doesn't find a value", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.MissingString"), "SecondTrivial.MissingString");
-                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
-            });
-        });
-        describe("Nonexisting Namespace", () => {
-            it("first level fails", () => {
-                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "FirstTrivial"), "FirstTrivial");
-                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "MissingKeyString"), "MissingKeyString");
-            });
-            it("second level fails", () => {
-                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "SecondTrivial.Test1"), "SecondTrivial.Test1");
-                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "Missing.String"), "Missing.String");
-            });
-            it("empty string namespace is treated as default namespace", () => {
-                chai_1.assert.equal(localization.getEnglishString("", "FirstTrivial"), "First level string (default)");
-                chai_1.assert.equal(localization.getEnglishString("", "SecondTrivial.Test1"), "Second level string 1 (default)");
-            });
-        });
-        // Test a few options to make sure they get passed through correctly
-        describe("With Options", () => {
-            it("returnDetails throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getEnglishString("Default", "X", { returnDetails: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("returnObjects throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getEnglishString("Default", "X", { returnObjects: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("returnDetails and returnObjects throws error", () => {
-                chai_1.assert.throws(() => {
-                    localization.getEnglishString("Default", "X", { returnDetails: true, returnObjects: true });
-                }, "Translation key must map to a string, but the given options will result in an object");
-            });
-            it("default value", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", "Missing", { defaultValue: "default" }), "default");
-            });
-            it("english takes priority over fallback language", () => {
-                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "OnlyEnglish", { fallbackLng: "de" }), "Hello");
-            });
-            // White box test
-            it("given namespace overrides namespace translation option", () => {
-                chai_1.assert.equal(localization.getEnglishString("Default", "FirstTrivial", { ns: "Test" }), "First level string (default)");
-                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1", ns: "Test" }), "First level CUSTOM1 (default)");
-            });
-        });
-    });
-    // Returned promises never have anything of substance, being only empty or resolving to null...
-    // describe("#getNamespacePromise", () => {
-    // });
-    describe("#getLanguageList", () => {
-        let languages;
-        it("english language list includes en and en-US", async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
-            await localization.initialize([]);
-            languages = localization.getLanguageList();
-            chai_1.assert.isTrue(languages.includes("en-US"));
-            chai_1.assert.isTrue(languages.includes("en"));
-        });
-        it("when non-english language is set as default, that language and english are included in langauge list", async () => {
-            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
-            await germanLocalization.initialize([]);
-            languages = germanLocalization.getLanguageList();
-            chai_1.assert.isTrue(languages.includes("en"));
-            chai_1.assert.isTrue(languages.includes("de"));
-        });
-    });
-    describe("#changeLanguage", () => {
-        it("change from english to another language", async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization();
-            await localization.initialize(["Default"]);
-            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)"); // english
-            await localization.changeLanguage("de");
-            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default german)"); // german
-        });
-        it("change from another language to english", async () => {
-            localization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
-            await localization.initialize(["Default"]);
-            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default german)"); // german
-            await localization.changeLanguage("en");
-            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)"); // english
-        });
-    });
-    describe("#registerNamespace", () => {
-        let itwinLocalization;
-        beforeEach(async () => {
-            itwinLocalization = new ITwinLocalization_1.ITwinLocalization();
-        });
-        it("can read from namespace after it is registered", async () => {
-            await itwinLocalization.initialize([]);
-            await itwinLocalization.registerNamespace("Test");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
-            chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
-        });
-        it("zero initial, register one", async () => {
-            await itwinLocalization.initialize([]);
-            await itwinLocalization.registerNamespace("test1");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
-        });
-        it("zero initial, register two", async () => {
-            await itwinLocalization.initialize([]);
-            await itwinLocalization.registerNamespace("test1");
-            await itwinLocalization.registerNamespace("test2");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test2"));
-        });
-        it("one initial, register one", async () => {
-            await itwinLocalization.initialize(["initial1"]);
-            await itwinLocalization.registerNamespace("test1");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
-        });
-        it("one initial, register two", async () => {
-            await itwinLocalization.initialize(["initial1"]);
-            await itwinLocalization.registerNamespace("test1");
-            await itwinLocalization.registerNamespace("test2");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test2"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
-        });
-        it("two initial, register one", async () => {
-            await itwinLocalization.initialize(["initial1", "initial2"]);
-            await itwinLocalization.registerNamespace("test1");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial2"));
-        });
-        it("two initial, register two", async () => {
-            await itwinLocalization.initialize(["initial1", "initial2"]);
-            await itwinLocalization.registerNamespace("test1");
-            await itwinLocalization.registerNamespace("test2");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial2"));
-        });
-        it("register duplicate namespaces", async () => {
-            await itwinLocalization.initialize([]);
-            await itwinLocalization.registerNamespace("Test");
-            await itwinLocalization.registerNamespace("Test");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
-            chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
-        });
-        it("register duplicate namespace of initial namespace doesn't break anything", async () => {
-            await itwinLocalization.initialize(["Test"]);
-            await itwinLocalization.registerNamespace("Test");
-            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
-            chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
-        });
-    });
-    // unregisterNamespace() isn't used and basically does nothing
-    // describe("#unregisterNamespace", () => {
-    // });
-});
+
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const chai_1 = __webpack_require__(/*! chai */ "../../common/temp/node_modules/.pnpm/chai@4.3.7/node_modules/chai/index.js");
+const ITwinLocalization_1 = __webpack_require__(/*! ../ITwinLocalization */ "./lib/cjs/ITwinLocalization.js");
+describe("ITwinLocalization", () => {
+    let localization;
+    let germanLocalization;
+    describe("#constructor", () => {
+        let itwinLocalization;
+        it("set default namespace", async () => {
+            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default" } });
+            await itwinLocalization.initialize([]);
+            chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
+            chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
+        });
+        it("set default language as english", async () => {
+            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default", lng: "en" } });
+            await itwinLocalization.initialize([]);
+            chai_1.assert.equal(itwinLocalization.i18next.options.lng, "en");
+            chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
+        });
+        it("set default language as NOT english", async () => {
+            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default", lng: "de" } });
+            await itwinLocalization.initialize([]);
+            chai_1.assert.equal(itwinLocalization.i18next.options.lng, "de");
+            chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default german)");
+        });
+        it("set fallback language as NOT english", async () => {
+            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default", fallbackLng: "de" } });
+            await itwinLocalization.initialize([]);
+            chai_1.assert.equal(itwinLocalization.i18next.options.fallbackLng, "de");
+            chai_1.assert.equal(itwinLocalization.getLocalizedString("OnlyGerman"), "Hallo");
+        });
+    });
+    describe("#initialize", () => {
+        let itwinLocalization;
+        it("cannot fetch from unregistered namespaces", async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization();
+            await localization.initialize([]);
+            chai_1.assert.equal(localization.getEnglishString("Default", "FirstTrivial"), "FirstTrivial");
+            chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial"), "FirstTrivial");
+        });
+        describe("with no default namespace predefined", () => {
+            before(() => {
+                itwinLocalization = new ITwinLocalization_1.ITwinLocalization();
+            });
+            it("no default namespace set when initialized with empty array", async () => {
+                await itwinLocalization.initialize([]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, undefined);
+            });
+            it("initialize with single namespace", async () => {
+                var _a;
+                await itwinLocalization.initialize(["Test"]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Test");
+                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Test"));
+                chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
+            });
+            it("initialize with two namespaces recognizes both namespaces", async () => {
+                var _a, _b;
+                await itwinLocalization.initialize(["Default", "Test"]);
+                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
+                chai_1.assert.isTrue((_b = itwinLocalization.i18next.options.ns) === null || _b === void 0 ? void 0 : _b.includes("Test"));
+                chai_1.assert.equal(itwinLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
+                chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
+            });
+            it("initialize with two namespaces sets first as default", async () => {
+                await itwinLocalization.initialize(["Default", "Test"]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
+                chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
+            });
+            it("initialize with duplicate namespace values does not break anything", async () => {
+                var _a;
+                await itwinLocalization.initialize(["Default", "Default"]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
+                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
+                chai_1.assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
+                chai_1.assert.equal(itwinLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
+            });
+        });
+        describe("with default namespace", () => {
+            before(() => {
+                itwinLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { defaultNS: "Default" } });
+            });
+            it("default namespace set when initialized with empty array", async () => {
+                await itwinLocalization.initialize([]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
+            });
+            it("default namespace not overridden by one namespace", async () => {
+                await itwinLocalization.initialize(["Test"]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
+            });
+            it("default namespace not overridden by two namespaces", async () => {
+                await itwinLocalization.initialize(["NotExist", "Test"]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
+            });
+            it("duplicate namespace value does not break default namespace", async () => {
+                await itwinLocalization.initialize(["Default"]);
+                chai_1.assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
+            });
+            it("default namespace is in list of all namespaces initalized with empty array", async () => {
+                var _a;
+                await itwinLocalization.initialize([]);
+                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
+            });
+            it("default namespace is in list of all namespaces", async () => {
+                var _a;
+                await itwinLocalization.initialize(["Test"]);
+                chai_1.assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
+            });
+        });
+    });
+    describe("#getLocalizedKeys", () => {
+        before(async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization();
+            await localization.initialize(["Default", "Test"]);
+            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
+            await germanLocalization.initialize(["Default", "Test"]);
+        });
+        it("no substitution", () => {
+            chai_1.assert.equal(localization.getLocalizedKeys("MyString"), "MyString");
+        });
+        describe("Default Namespace", () => {
+            it("first level string", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{FirstTrivial}"), "hi First level string (default)");
+                chai_1.assert.equal(germanLocalization.getLocalizedKeys("hi %{FirstTrivial}"), "hi First level string (default german)");
+            });
+            it("second level string", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{SecondTrivial.Test1}"), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("bye %{SecondTrivial.Test2}"), "bye Second level string 2 (default)");
+                chai_1.assert.equal(germanLocalization.getLocalizedKeys("%{SecondTrivial.Test1}"), "Second level string 1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedKeys("bye %{SecondTrivial.Test2}"), "bye Second level string 2 (default german)");
+            });
+            it("first level string with keys", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{FirstSubstitution1}"), "First level {{str}} (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("bye %{FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default)");
+                chai_1.assert.equal(germanLocalization.getLocalizedKeys("%{FirstSubstitution1}"), "First level {{str}} (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedKeys("bye %{FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default german)");
+            });
+            it("second level string with keys", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default)");
+                chai_1.assert.equal(germanLocalization.getLocalizedKeys("%{SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedKeys("hi %{SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default german)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("no %{MissingKeyString}"), "no MissingKeyString");
+                chai_1.assert.equal(localization.getLocalizedKeys("no %{MissingKeyString}"), "no MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Given Namespace", () => {
+            it("first level string", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Default:FirstTrivial}"), "hi First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Test:FirstTrivial}"), "hi First level string (test)");
+            });
+            it("second level string", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:SecondTrivial.Test1}"), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Default:SecondTrivial.Test2}"), "bye Second level string 2 (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:SecondTrivial.Test1}"), "Second level string 1 (test)");
+                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Test:SecondTrivial.Test2}"), "bye Second level string 2 (test)");
+            });
+            it("first level string with keys", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:FirstSubstitution1}"), "First level {{str}} (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Default:FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:FirstSubstitution1}"), "First level {{str}} (test)");
+                chai_1.assert.equal(localization.getLocalizedKeys("bye %{Test:FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (test)");
+            });
+            it("second level string with keys", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Default:SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default)");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (test)");
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Test:SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (test)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("no %{Default:MissingKeyString}"), "no MissingKeyString");
+                chai_1.assert.equal(localization.getLocalizedKeys("no %{Test:MissingKeyString}"), "no MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Default:SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Default:MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
+                chai_1.assert.equal(localization.getLocalizedKeys("hi %{Test:SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Test:MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Nonexisting Namespace", () => {
+            it("first level fails", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:FirstTrivial}"), "FirstTrivial");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:MissingKeyString}"), "MissingKeyString");
+            });
+            it("second level fails", () => {
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:SecondTrivial.Test1}"), "SecondTrivial.Test1");
+                chai_1.assert.equal(localization.getLocalizedKeys("%{Nonexisting:Missing.String}"), "Missing.String");
+            });
+        });
+    });
+    // The goal is not to test i18next's interpolation,
+    // but just to have some simple tests to make sure the
+    // basics work through the ITwinLocalization class.
+    // For interpolation options, see: https://www.i18next.com/translation-function/interpolation
+    describe("#getLocalizedString", () => {
+        before(async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization();
+            await localization.initialize(["Default", "Test"]);
+            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
+            await germanLocalization.initialize(["Default", "Test"]);
+        });
+        describe("Default Namespace", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)");
+            });
+            it("first level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"]), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstTrivial"]), "First level string (default)");
+            });
+            it("more than two fallback keys succeeds", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist1", "NotExist2"]), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist1", "FirstTrivial", "NotExist2"]), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist1", "NotExist2", "FirstTrivial"]), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["1", "2", "3", "4", "5", "FirstTrivial"]), "First level string (default)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1"), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test2"), "Second level string 2 (default)");
+            });
+            it("second level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (default)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
+            });
+            it("first level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
+            });
+            it("second level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString"), "MissingKeyString");
+            });
+            it("first level missing all keys doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["MissingKeyString", "MissingString2"]), "MissingString2");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.MissingString"), "SecondTrivial.MissingString");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "MissingKeyObject.MissingString"]), "MissingKeyObject.MissingString");
+            });
+            it("read from en-US fallback", () => {
+                chai_1.assert.equal(localization.getLocalizedString("OnlyEnglishUS"), "HelloUS");
+            });
+        });
+        describe("Default Namespace (German)", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstTrivial"), "First level string (default german)");
+            });
+            it("first level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["FirstTrivial", "NotExist"]), "First level string (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstTrivial"]), "First level string (default german)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1"), "Second level string 1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2"), "Second level string 2 (default german)");
+            });
+            it("second level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (default german)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
+            });
+            it("first level with substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
+            });
+            it("second level with substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyString"), "MissingKeyString");
+            });
+            it("first level missing all keys doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["MissingKeyString", "MissingString2"]), "MissingString2");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.MissingString"), "SecondTrivial.MissingString");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Given Namespace", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
+            });
+            it("first level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["Default:FirstTrivial", "Not:NotExist"]), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["Default:NotExist", "Test:FirstTrivial"]), "First level string (test)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:SecondTrivial.Test1"), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Default:SecondTrivial.Test2"), "Second level string 2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test1"), "Second level string 1 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test2"), "Second level string 2 (test)");
+            });
+            it("second level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:SecondTrivial.Test1"]), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["Test:SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Default:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
+            });
+            it("first level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["Test:FirstSubstitution1", "Default:NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Default:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("second level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["Test:SecondSubstitution.Test2", "Default:NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:MissingKeyString"), "MissingKeyString");
+                chai_1.assert.equal(localization.getLocalizedString("Test:MissingKeyString"), "MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.MissingString"), "SecondTrivial.MissingString");
+                chai_1.assert.equal(localization.getLocalizedString("Test:MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
+            });
+            it("read from en-US fallback", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:OnlyEnglishUS"), "HelloUS");
+            });
+        });
+        describe("Given Namespace (German)", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (german)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondTrivial.Test1"), "Second level string 1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondTrivial.Test2"), "Second level string 2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.Test1"), "Second level string 1 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.Test2"), "Second level string 2 (german)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (german)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (german)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:MissingKeyString"), "MissingKeyString");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:MissingKeyString"), "MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.MissingString"), "SecondTrivial.MissingString");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Test:MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Nonexisting Namespace", () => {
+            it("first level fails", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:FirstTrivial"), "FirstTrivial");
+                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:MissingKeyString"), "MissingKeyString");
+            });
+            it("second level fails", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:SecondTrivial.Test1"), "SecondTrivial.Test1");
+                chai_1.assert.equal(localization.getLocalizedString("Nonexisting:Missing.String"), "Missing.String");
+            });
+            it("fallback key fails", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["Nonexisting:FirstTrivial", "NotExist"]), "NotExist");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "Nonexisting:Missing.String"]), "Missing.String");
+            });
+        });
+        // Test a few options to make sure they get passed through correctly
+        describe("With Options", () => {
+            it("returnDetails throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getLocalizedString("X", { returnDetails: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("returnObjects throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getLocalizedString("X", { returnObjects: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("returnDetails and returnObjects throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getLocalizedString("X", { returnDetails: true, returnObjects: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("default value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Missing", { defaultValue: "default" }), "default");
+            });
+            it("override fallback language", () => {
+                // Doesn't fallback to English
+                chai_1.assert.equal(germanLocalization.getLocalizedString("OnlyEnglish", { fallbackLng: "de" }), "OnlyEnglish");
+            });
+            it("set namespace", () => {
+                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (test)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1", ns: "Test" }), "First level CUSTOM1 (test)");
+            });
+        });
+    });
+    describe("#getLocalizedString with namespace passed in as an option", () => {
+        before(async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization();
+            await localization.initialize(["Default", "Test"]);
+            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
+            await germanLocalization.initialize(["Default", "Test"]);
+        });
+        describe("Keys Without Namespaces", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Default" }), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (test)");
+            });
+            it("first level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"], { ns: "Default" }), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstTrivial"], { ns: "Test" }), "First level string (test)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Default" }), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test2", { ns: "Default" }), "Second level string 2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test2", { ns: "Test" }), "Second level string 2 (test)");
+            });
+            it("second level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondTrivial.Test1"], { ns: "Default" }), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["SecondTrivial.Test2", "NotExist"], { ns: "Test" }), "Second level string 2 (test)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM2" }), "First level CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution2", { ns: "Default", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM1" }), "First level CUSTOM1 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("FirstSubstitution2", { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
+            });
+            it("first level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution1"], { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["FirstSubstitution1", "NotExist"], { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution2"], { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("second level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Default" }), "MissingKeyString");
+                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Test" }), "MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.MissingString", { ns: "Test" }), "SecondTrivial.MissingString");
+                chai_1.assert.equal(localization.getLocalizedString("MissingKeyObject.MissingString", { ns: "Test" }), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Keys Without Namespaces (German)", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstTrivial", { ns: "Default" }), "First level string (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (german)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1", { ns: "Default" }), "Second level string 1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2", { ns: "Default" }), "Second level string 2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2", { ns: "Test" }), "Second level string 2 (german)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { ns: "Default", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM1" }), "First level CUSTOM1 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (german)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (german)");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (german)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyString", { ns: "Default" }), "MissingKeyString");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyString", { ns: "Test" }), "MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("SecondTrivial.MissingString", { ns: "Test" }), "SecondTrivial.MissingString");
+                chai_1.assert.equal(germanLocalization.getLocalizedString("MissingKeyObject.MissingString", { ns: "Test" }), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Keys With Namespaces", () => {
+            it("key with same namespace works", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Default" }), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (test)");
+            });
+            it("key with different namespace overrides given namespace", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial", { ns: "Default" }), "First level string (test)");
+                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Test" }), "First level string (default)");
+            });
+            it("key with same namespace works with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Default:FirstTrivial"], { ns: "Default" }), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Test:FirstTrivial"], { ns: "Test" }), "First level string (test)");
+            });
+            it("key with different namespace overrides given namespace with fallback keys", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Test:FirstTrivial"], { ns: "Default" }), "First level string (test)");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Default:FirstTrivial"], { ns: "Test" }), "First level string (default)");
+            });
+            it("missing key does not find a value", () => {
+                chai_1.assert.equal(germanLocalization.getLocalizedString("Default:MissingKeyString", { ns: "Default" }), "MissingKeyString");
+                chai_1.assert.equal(germanLocalization.getLocalizedString(["Missing1", "MissingKeyObject.MissingString"], { ns: "Test" }), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Nonexisting Namespace", () => {
+            it("first level fails", () => {
+                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Nonexisting" }), "FirstTrivial");
+                chai_1.assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Nonexisting" }), "MissingKeyString");
+            });
+            it("second level fails", () => {
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Nonexisting" }), "SecondTrivial.Test1");
+                chai_1.assert.equal(localization.getLocalizedString("Missing.String", { ns: "Nonexisting" }), "Missing.String");
+            });
+            it("empty string namespace falls back to default namespace", () => {
+                chai_1.assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "" }), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "" }), "Second level string 1 (default)");
+            });
+            it("fallback key fails", () => {
+                chai_1.assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"], { ns: "Nonexisting" }), "NotExist");
+                chai_1.assert.equal(localization.getLocalizedString(["NotExist", "Missing.String"], { ns: "Nonexisting" }), "Missing.String");
+            });
+            it("use key with valid namespace instead", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Nonexisting" }), "First level string (default)");
+                chai_1.assert.equal(localization.getLocalizedString("Test:FirstTrivial", { ns: "Nonexisting" }), "First level string (test)");
+            });
+            it("providing key with invalid namespace fails", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Nonexisting2:FirstTrivial", { ns: "Nonexisting1" }), "FirstTrivial");
+            });
+        });
+        // Test a few options to make sure they get passed through correctly
+        describe("With Options", () => {
+            it("returnDetails throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getLocalizedString("X", { ns: "Default", returnDetails: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("returnObjects throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getLocalizedString("X", { ns: "Default", returnObjects: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("returnDetails and returnObjects throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getLocalizedString("X", { ns: "Default", returnDetails: true, returnObjects: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("default value", () => {
+                chai_1.assert.equal(localization.getLocalizedString("Missing", { ns: "Default", defaultValue: "default" }), "default");
+            });
+            it("override fallback language", () => {
+                // Doesn't fallback to English
+                chai_1.assert.equal(germanLocalization.getLocalizedString("OnlyEnglish", { ns: "Default", fallbackLng: "de" }), "OnlyEnglish");
+            });
+        });
+    });
+    describe("#getEnglishString", () => {
+        before(async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization();
+            await localization.initialize(["Default", "Test"]);
+            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
+            await germanLocalization.initialize(["Default", "Test"]);
+        });
+        describe("Given Namespace", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", "FirstTrivial"), "First level string (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "FirstTrivial"), "First level string (test)");
+            });
+            it("first level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", ["FirstTrivial", "NotExist"]), "First level string (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", ["NotExist", "FirstTrivial"]), "First level string (test)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", "SecondTrivial.Test1"), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Default", "SecondTrivial.Test2"), "Second level string 2 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "SecondTrivial.Test1"), "Second level string 1 (test)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "SecondTrivial.Test2"), "Second level string 2 (test)");
+            });
+            it("second level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", ["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", ["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
+            });
+            it("first level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", ["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", ["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(localization.getEnglishString("Test", ["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Default", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
+                chai_1.assert.equal(localization.getEnglishString("Test", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("second level with substitution with fallback keys", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", ["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(localization.getEnglishString("Test", ["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", "MissingKeyString"), "MissingKeyString");
+                chai_1.assert.equal(localization.getEnglishString("Test", "MissingKeyString"), "MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(localization.getEnglishString("Test", "SecondTrivial.MissingString"), "SecondTrivial.MissingString");
+                chai_1.assert.equal(localization.getEnglishString("Test", "MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Given Namespace with German default language returns English strings", () => {
+            it("first level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstTrivial"), "First level string (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstTrivial"), "First level string (test)");
+            });
+            it("first level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["FirstTrivial", "NotExist"]), "First level string (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["NotExist", "FirstTrivial"]), "First level string (test)");
+            });
+            it("second level with no substitution", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondTrivial.Test1"), "Second level string 1 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondTrivial.Test2"), "Second level string 2 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.Test1"), "Second level string 1 (test)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.Test2"), "Second level string 2 (test)");
+            });
+            it("second level with no substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
+            });
+            it("first level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
+            });
+            it("first level with substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
+            });
+            it("second level with substitution", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("second level with substitution with fallback keys", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", ["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
+            });
+            it("first level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "MissingKeyString"), "MissingKeyString");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "MissingKeyString"), "MissingKeyString");
+            });
+            it("second level missing key doesn't find a value", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.MissingString"), "SecondTrivial.MissingString");
+                chai_1.assert.equal(germanLocalization.getEnglishString("Test", "MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
+            });
+        });
+        describe("Nonexisting Namespace", () => {
+            it("first level fails", () => {
+                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "FirstTrivial"), "FirstTrivial");
+                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "MissingKeyString"), "MissingKeyString");
+            });
+            it("second level fails", () => {
+                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "SecondTrivial.Test1"), "SecondTrivial.Test1");
+                chai_1.assert.equal(localization.getEnglishString("Nonexisting", "Missing.String"), "Missing.String");
+            });
+            it("empty string namespace is treated as default namespace", () => {
+                chai_1.assert.equal(localization.getEnglishString("", "FirstTrivial"), "First level string (default)");
+                chai_1.assert.equal(localization.getEnglishString("", "SecondTrivial.Test1"), "Second level string 1 (default)");
+            });
+        });
+        // Test a few options to make sure they get passed through correctly
+        describe("With Options", () => {
+            it("returnDetails throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getEnglishString("Default", "X", { returnDetails: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("returnObjects throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getEnglishString("Default", "X", { returnObjects: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("returnDetails and returnObjects throws error", () => {
+                chai_1.assert.throws(() => {
+                    localization.getEnglishString("Default", "X", { returnDetails: true, returnObjects: true });
+                }, "Translation key must map to a string, but the given options will result in an object");
+            });
+            it("default value", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", "Missing", { defaultValue: "default" }), "default");
+            });
+            it("english takes priority over fallback language", () => {
+                chai_1.assert.equal(germanLocalization.getEnglishString("Default", "OnlyEnglish", { fallbackLng: "de" }), "Hello");
+            });
+            // White box test
+            it("given namespace overrides namespace translation option", () => {
+                chai_1.assert.equal(localization.getEnglishString("Default", "FirstTrivial", { ns: "Test" }), "First level string (default)");
+                chai_1.assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1", ns: "Test" }), "First level CUSTOM1 (default)");
+            });
+        });
+    });
+    // Returned promises never have anything of substance, being only empty or resolving to null...
+    // describe("#getNamespacePromise", () => {
+    // });
+    describe("#getLanguageList", () => {
+        let languages;
+        it("english language list includes en and en-US", async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization();
+            await localization.initialize([]);
+            languages = localization.getLanguageList();
+            chai_1.assert.isTrue(languages.includes("en-US"));
+            chai_1.assert.isTrue(languages.includes("en"));
+        });
+        it("when non-english language is set as default, that language and english are included in langauge list", async () => {
+            germanLocalization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
+            await germanLocalization.initialize([]);
+            languages = germanLocalization.getLanguageList();
+            chai_1.assert.isTrue(languages.includes("en"));
+            chai_1.assert.isTrue(languages.includes("de"));
+        });
+    });
+    describe("#changeLanguage", () => {
+        it("change from english to another language", async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization();
+            await localization.initialize(["Default"]);
+            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)"); // english
+            await localization.changeLanguage("de");
+            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default german)"); // german
+        });
+        it("change from another language to english", async () => {
+            localization = new ITwinLocalization_1.ITwinLocalization({ initOptions: { lng: "de" } });
+            await localization.initialize(["Default"]);
+            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default german)"); // german
+            await localization.changeLanguage("en");
+            chai_1.assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)"); // english
+        });
+    });
+    describe("#registerNamespace", () => {
+        let itwinLocalization;
+        beforeEach(async () => {
+            itwinLocalization = new ITwinLocalization_1.ITwinLocalization();
+        });
+        it("can read from namespace after it is registered", async () => {
+            await itwinLocalization.initialize([]);
+            await itwinLocalization.registerNamespace("Test");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
+            chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
+        });
+        it("zero initial, register one", async () => {
+            await itwinLocalization.initialize([]);
+            await itwinLocalization.registerNamespace("test1");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
+        });
+        it("zero initial, register two", async () => {
+            await itwinLocalization.initialize([]);
+            await itwinLocalization.registerNamespace("test1");
+            await itwinLocalization.registerNamespace("test2");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test2"));
+        });
+        it("one initial, register one", async () => {
+            await itwinLocalization.initialize(["initial1"]);
+            await itwinLocalization.registerNamespace("test1");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
+        });
+        it("one initial, register two", async () => {
+            await itwinLocalization.initialize(["initial1"]);
+            await itwinLocalization.registerNamespace("test1");
+            await itwinLocalization.registerNamespace("test2");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test2"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
+        });
+        it("two initial, register one", async () => {
+            await itwinLocalization.initialize(["initial1", "initial2"]);
+            await itwinLocalization.registerNamespace("test1");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial2"));
+        });
+        it("two initial, register two", async () => {
+            await itwinLocalization.initialize(["initial1", "initial2"]);
+            await itwinLocalization.registerNamespace("test1");
+            await itwinLocalization.registerNamespace("test2");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial2"));
+        });
+        it("register duplicate namespaces", async () => {
+            await itwinLocalization.initialize([]);
+            await itwinLocalization.registerNamespace("Test");
+            await itwinLocalization.registerNamespace("Test");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
+            chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
+        });
+        it("register duplicate namespace of initial namespace doesn't break anything", async () => {
+            await itwinLocalization.initialize(["Test"]);
+            await itwinLocalization.registerNamespace("Test");
+            chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
+            chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
+        });
+    });
+    // unregisterNamespace() isn't used and basically does nothing
+    // describe("#unregisterNamespace", () => {
+    // });
+});
 
 })();