@itwin/core-i18n 3.7.11 → 3.7.13

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

@@ -22336,237 +22336,237 @@ function partitionArray(array, criterion) {
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ITwinLocalization = void 0;
-const i18next_1 = __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 = __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 = __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 = __webpack_require__(/*! @itwin/core-bentley */ "../bentley/lib/esm/core-bentley.js");
-const DEFAULT_MAX_RETRIES = 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) {
-        var _a, _b, _c;
-        this._namespaces = new Map();
-        this.i18next = i18next_1.default.createInstance();
-        this._backendOptions = {
-            loadPath: (_a = options === null || options === void 0 ? void 0 : options.urlTemplate) !== null && _a !== void 0 ? _a : "locales/{{lng}}/{{ns}}.json",
-            crossDomain: true,
-            ...options === null || options === void 0 ? void 0 : options.backendHttpOptions,
-        };
-        this._detectionOptions = {
-            order: ["querystring", "navigator", "htmlTag"],
-            lookupQuerystring: "lng",
-            caches: [],
-            ...options === null || options === void 0 ? void 0 : options.detectorOptions,
-        };
-        this._initOptions = {
-            interpolation: { escapeValue: true },
-            fallbackLng: "en",
-            maxRetries: DEFAULT_MAX_RETRIES,
-            backend: this._backendOptions,
-            detection: this._detectionOptions,
-            ...options === null || options === void 0 ? void 0 : options.initOptions,
-        };
-        this.i18next
-            .use((_b = options === null || options === void 0 ? void 0 : options.detectorPlugin) !== null && _b !== void 0 ? _b : i18next_browser_languagedetector_1.default)
-            .use((_c = options === null || options === void 0 ? void 0 : options.backendPlugin) !== null && _c !== void 0 ? _c : i18next_http_backend_1.default)
-            .use(TranslationLogger);
-    }
-    async initialize(namespaces) {
-        var _a;
-        // Also consider namespaces passed into constructor
-        const initNamespaces = [this._initOptions.ns || []].flat();
-        const combinedNamespaces = new Set([...namespaces, ...initNamespaces]); // without duplicates
-        const defaultNamespace = (_a = this._initOptions.defaultNS) !== null && _a !== void 0 ? _a : namespaces[0];
-        if (defaultNamespace)
-            combinedNamespaces.add(defaultNamespace); // Make sure default namespace is in namespaces list
-        const initOptions = {
-            ...this._initOptions,
-            defaultNS: defaultNamespace,
-            ns: [...combinedNamespaces],
-        };
-        // if in a development environment, set debugging
-        if (false)
-            {}
-        const initPromise = this.i18next.init(initOptions);
-        for (const ns of namespaces)
-            this._namespaces.set(ns, initPromise);
-        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
-     */
-    getLocalizedKeys(line) {
-        return line.replace(/\%\{(.+?)\}/g, (_match, tag) => 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
-     */
-    getLocalizedString(key, options) {
-        if ((options === null || options === void 0 ? void 0 : options.returnDetails) || (options === null || options === void 0 ? void 0 : options.returnObjects)) {
-            throw new Error("Translation key must map to a string, but the given options will result in an object");
-        }
-        const value = this.i18next.t(key, options);
-        if (typeof value !== "string") {
-            throw new Error("Translation key(s) string not found");
-        }
-        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
-     */
-    getLocalizedStringWithNamespace(namespace, key, options) {
-        let fullKey = "";
-        if (typeof key === "string") {
-            fullKey = `${namespace}:${key}`;
-        }
-        else {
-            fullKey = key.map((subKey) => {
-                return `${namespace}:${subKey}`;
-            });
-        }
-        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
-     */
-    getEnglishString(namespace, key, options) {
-        if ((options === null || options === void 0 ? void 0 : options.returnDetails) || (options === null || options === void 0 ? void 0 : options.returnObjects)) {
-            throw new Error("Translation key must map to a string, but the given options will result in an object");
-        }
-        options = {
-            ...options,
-            ns: namespace, // ensure namespace argument is used
-        };
-        const en = this.i18next.getFixedT("en", namespace);
-        const str = en(key, options);
-        if (typeof str !== "string")
-            throw new Error("Translation key(s) not found");
-        return str;
-    }
-    /** Get the promise for an already registered Namespace.
-     * @param name - the name of the namespace
-     * @public
-     */
-    getNamespacePromise(name) {
-        return this._namespaces.get(name);
-    }
-    /** @internal */
-    getLanguageList() {
-        return this.i18next.languages;
-    }
-    /** override the language detected in the browser  */
-    async changeLanguage(language) {
-        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
-     */
-    async registerNamespace(name) {
-        const existing = this._namespaces.get(name);
-        if (existing !== undefined)
-            return existing;
-        const theReadPromise = new Promise((resolve) => {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.i18next.loadNamespaces(name, (err) => {
-                if (!err)
-                    return resolve();
-                // 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 = this.getLanguageList().map((thisLocale) => `/${thisLocale}/`);
-                try {
-                    for (const thisError of err) {
-                        if (typeof thisError === "string")
-                            locales = locales.filter((thisLocale) => !thisError.includes(thisLocale));
-                    }
-                }
-                catch (e) {
-                    locales = [];
-                }
-                // if we removed every locale from the array, it wasn't loaded.
-                if (locales.length === 0)
-                    core_bentley_1.Logger.logError("i18n", `No resources for namespace ${name} could be loaded`);
-                resolve();
-            });
-        });
-        this._namespaces.set(name, theReadPromise);
-        return theReadPromise;
-    }
-    /** @internal */
-    unregisterNamespace(name) {
-        this._namespaces.delete(name);
-    }
-}
-exports.ITwinLocalization = ITwinLocalization;
-class TranslationLogger {
-    log(args) { core_bentley_1.Logger.logInfo("i18n", this.createLogMessage(args)); }
-    warn(args) { core_bentley_1.Logger.logWarning("i18n", this.createLogMessage(args)); }
-    error(args) { core_bentley_1.Logger.logError("i18n", this.createLogMessage(args)); }
-    createLogMessage(args) {
-        let message = args[0];
-        for (let i = 1; i < args.length; ++i) {
-            if (typeof args[i] === "string")
-                message += `\n  ${args[i]}`;
-        }
-        return message;
-    }
-}
-TranslationLogger.type = "logger";
+
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ITwinLocalization = void 0;
+const i18next_1 = __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 = __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 = __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 = __webpack_require__(/*! @itwin/core-bentley */ "../bentley/lib/esm/core-bentley.js");
+const DEFAULT_MAX_RETRIES = 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) {
+        var _a, _b, _c;
+        this._namespaces = new Map();
+        this.i18next = i18next_1.default.createInstance();
+        this._backendOptions = {
+            loadPath: (_a = options === null || options === void 0 ? void 0 : options.urlTemplate) !== null && _a !== void 0 ? _a : "locales/{{lng}}/{{ns}}.json",
+            crossDomain: true,
+            ...options === null || options === void 0 ? void 0 : options.backendHttpOptions,
+        };
+        this._detectionOptions = {
+            order: ["querystring", "navigator", "htmlTag"],
+            lookupQuerystring: "lng",
+            caches: [],
+            ...options === null || options === void 0 ? void 0 : options.detectorOptions,
+        };
+        this._initOptions = {
+            interpolation: { escapeValue: true },
+            fallbackLng: "en",
+            maxRetries: DEFAULT_MAX_RETRIES,
+            backend: this._backendOptions,
+            detection: this._detectionOptions,
+            ...options === null || options === void 0 ? void 0 : options.initOptions,
+        };
+        this.i18next
+            .use((_b = options === null || options === void 0 ? void 0 : options.detectorPlugin) !== null && _b !== void 0 ? _b : i18next_browser_languagedetector_1.default)
+            .use((_c = options === null || options === void 0 ? void 0 : options.backendPlugin) !== null && _c !== void 0 ? _c : i18next_http_backend_1.default)
+            .use(TranslationLogger);
+    }
+    async initialize(namespaces) {
+        var _a;
+        // Also consider namespaces passed into constructor
+        const initNamespaces = [this._initOptions.ns || []].flat();
+        const combinedNamespaces = new Set([...namespaces, ...initNamespaces]); // without duplicates
+        const defaultNamespace = (_a = this._initOptions.defaultNS) !== null && _a !== void 0 ? _a : namespaces[0];
+        if (defaultNamespace)
+            combinedNamespaces.add(defaultNamespace); // Make sure default namespace is in namespaces list
+        const initOptions = {
+            ...this._initOptions,
+            defaultNS: defaultNamespace,
+            ns: [...combinedNamespaces],
+        };
+        // if in a development environment, set debugging
+        if (false)
+            {}
+        const initPromise = this.i18next.init(initOptions);
+        for (const ns of namespaces)
+            this._namespaces.set(ns, initPromise);
+        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
+     */
+    getLocalizedKeys(line) {
+        return line.replace(/\%\{(.+?)\}/g, (_match, tag) => 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
+     */
+    getLocalizedString(key, options) {
+        if ((options === null || options === void 0 ? void 0 : options.returnDetails) || (options === null || options === void 0 ? void 0 : options.returnObjects)) {
+            throw new Error("Translation key must map to a string, but the given options will result in an object");
+        }
+        const value = this.i18next.t(key, options);
+        if (typeof value !== "string") {
+            throw new Error("Translation key(s) string not found");
+        }
+        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
+     */
+    getLocalizedStringWithNamespace(namespace, key, options) {
+        let fullKey = "";
+        if (typeof key === "string") {
+            fullKey = `${namespace}:${key}`;
+        }
+        else {
+            fullKey = key.map((subKey) => {
+                return `${namespace}:${subKey}`;
+            });
+        }
+        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
+     */
+    getEnglishString(namespace, key, options) {
+        if ((options === null || options === void 0 ? void 0 : options.returnDetails) || (options === null || options === void 0 ? void 0 : options.returnObjects)) {
+            throw new Error("Translation key must map to a string, but the given options will result in an object");
+        }
+        options = {
+            ...options,
+            ns: namespace, // ensure namespace argument is used
+        };
+        const en = this.i18next.getFixedT("en", namespace);
+        const str = en(key, options);
+        if (typeof str !== "string")
+            throw new Error("Translation key(s) not found");
+        return str;
+    }
+    /** Get the promise for an already registered Namespace.
+     * @param name - the name of the namespace
+     * @public
+     */
+    getNamespacePromise(name) {
+        return this._namespaces.get(name);
+    }
+    /** @internal */
+    getLanguageList() {
+        return this.i18next.languages;
+    }
+    /** override the language detected in the browser  */
+    async changeLanguage(language) {
+        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
+     */
+    async registerNamespace(name) {
+        const existing = this._namespaces.get(name);
+        if (existing !== undefined)
+            return existing;
+        const theReadPromise = new Promise((resolve) => {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.i18next.loadNamespaces(name, (err) => {
+                if (!err)
+                    return resolve();
+                // 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 = this.getLanguageList().map((thisLocale) => `/${thisLocale}/`);
+                try {
+                    for (const thisError of err) {
+                        if (typeof thisError === "string")
+                            locales = locales.filter((thisLocale) => !thisError.includes(thisLocale));
+                    }
+                }
+                catch (e) {
+                    locales = [];
+                }
+                // if we removed every locale from the array, it wasn't loaded.
+                if (locales.length === 0)
+                    core_bentley_1.Logger.logError("i18n", `No resources for namespace ${name} could be loaded`);
+                resolve();
+            });
+        });
+        this._namespaces.set(name, theReadPromise);
+        return theReadPromise;
+    }
+    /** @internal */
+    unregisterNamespace(name) {
+        this._namespaces.delete(name);
+    }
+}
+exports.ITwinLocalization = ITwinLocalization;
+class TranslationLogger {
+    log(args) { core_bentley_1.Logger.logInfo("i18n", this.createLogMessage(args)); }
+    warn(args) { core_bentley_1.Logger.logWarning("i18n", this.createLogMessage(args)); }
+    error(args) { core_bentley_1.Logger.logError("i18n", this.createLogMessage(args)); }
+    createLogMessage(args) {
+        let message = args[0];
+        for (let i = 1; i < args.length; ++i) {
+            if (typeof args[i] === "string")
+                message += `\n  ${args[i]}`;
+        }
+        return message;
+    }
+}
+TranslationLogger.type = "logger";
 
 
 /***/ }),
@@ -23399,874 +23399,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", () => {
+    // });
+});
 
 })();