@microsoft/vscode-azext-azureauth 5.1.1 → 6.0.0-alpha.2

package/dist/esm/src/utils/Limiter.js

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class Limiter {
+    runningPromises;
+    maxDegreeOfParalellism;
+    outstandingPromises;
+    constructor(maxDegreeOfParalellism) {
+        this.maxDegreeOfParalellism = maxDegreeOfParalellism;
+        this.outstandingPromises = [];
+        this.runningPromises = 0;
+    }
+    queue(factory) {
+        return new Promise((c, e) => {
+            this.outstandingPromises.push({ factory, c, e });
+            this.consume();
+        });
+    }
+    consume() {
+        while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {
+            const iLimitedTask = this.outstandingPromises.shift();
+            this.runningPromises++;
+            const promise = iLimitedTask.factory();
+            promise.then(iLimitedTask.c, iLimitedTask.e);
+            promise.then(() => this.consumed(), () => this.consumed());
+        }
+    }
+    consumed() {
+        this.runningPromises--;
+        if (this.outstandingPromises.length > 0) {
+            this.consume();
+        }
+    }
+}
+/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+//# sourceMappingURL=Limiter.js.map

package/dist/esm/src/{NotSignedInError.d.ts → utils/NotSignedInError.d.ts}

@@ -6,10 +6,10 @@ export declare class NotSignedInError extends Error {
     constructor();
 }
 /**
- * Tests if an object is a `NotSignedInError`. This should be used instead of `instanceof`.
+ * Tests if an object is a {@link NotSignedInError}. This should be used instead of `instanceof`.
  *
  * @param error The object to test
  *
- * @returns True if the object is a NotSignedInError, false otherwise
+ * @returns True if the object is a {@link NotSignedInError}, false otherwise
  */
 export declare function isNotSignedInError(error: unknown): error is NotSignedInError;

package/dist/esm/src/{NotSignedInError.js → utils/NotSignedInError.js}

@@ -13,13 +13,14 @@ export class NotSignedInError extends Error {
     }
 }
 /**
- * Tests if an object is a `NotSignedInError`. This should be used instead of `instanceof`.
+ * Tests if an object is a {@link NotSignedInError}. This should be used instead of `instanceof`.
  *
  * @param error The object to test
  *
- * @returns True if the object is a NotSignedInError, false otherwise
+ * @returns True if the object is a {@link NotSignedInError}, false otherwise
  */
 export function isNotSignedInError(error) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare, @typescript-eslint/no-unnecessary-condition
     return !!error && typeof error === 'object' && error.isNotSignedInError === true;
 }
 //# sourceMappingURL=NotSignedInError.js.map

package/dist/esm/src/utils/configuredAzureEnv.d.ts

@@ -1,13 +1,15 @@
 import * as azureEnv from '@azure/ms-rest-azure-env';
 import * as vscode from 'vscode';
+declare class ExtendedEnvironment extends azureEnv.Environment {
+    readonly isCustomCloud: boolean;
+    constructor(parameters: azureEnv.EnvironmentParameters, isCustomCloud: boolean);
+}
 /**
  * Gets the configured Azure environment.
  *
  * @returns The configured Azure environment from the settings in the built-in authentication provider extension
  */
-export declare function getConfiguredAzureEnv(): azureEnv.Environment & {
-    isCustomCloud: boolean;
-};
+export declare function getConfiguredAzureEnv(): ExtendedEnvironment;
 /**
  * Sets the configured Azure cloud.
  *
@@ -16,9 +18,10 @@ export declare function getConfiguredAzureEnv(): azureEnv.Environment & {
  *
  * @param target (Optional) The configuration target to use, by default {@link vscode.ConfigurationTarget.Global}.
  */
-export declare function setConfiguredAzureEnv(cloud: 'AzureCloud' | 'ChinaCloud' | 'USGovernment' | undefined | azureEnv.EnvironmentParameters, target?: vscode.ConfigurationTarget): Promise<void>;
+export declare function setConfiguredAzureEnv(cloud: 'AzureCloud' | 'ChinaCloud' | 'USGovernment' | undefined | null | azureEnv.EnvironmentParameters, target?: vscode.ConfigurationTarget): Promise<void>;
 /**
  * Gets the ID of the authentication provider configured to be used
  * @returns The provider ID to use, either `'microsoft'` or `'microsoft-sovereign-cloud'`
  */
 export declare function getConfiguredAuthProviderId(): string;
+export {};

package/dist/esm/src/utils/configuredAzureEnv.js

@@ -14,6 +14,16 @@ var CloudEnvironmentSettingValue;
     CloudEnvironmentSettingValue["USGovernment"] = "USGovernment";
     CloudEnvironmentSettingValue["Custom"] = "custom";
 })(CloudEnvironmentSettingValue || (CloudEnvironmentSettingValue = {}));
+class ExtendedEnvironment extends azureEnv.Environment {
+    isCustomCloud;
+    constructor(parameters, isCustomCloud) {
+        super(parameters);
+        this.isCustomCloud = isCustomCloud;
+        // The Environment constructor only copies required properties. Copy all remaining
+        // optional properties (e.g. storageEndpointSuffix, keyVaultDnsSuffix) from the source.
+        Object.assign(this, parameters);
+    }
+}
 /**
  * Gets the configured Azure environment.
  *
@@ -23,31 +33,19 @@ export function getConfiguredAzureEnv() {
     const authProviderConfig = vscode.workspace.getConfiguration(CustomCloudConfigurationSection);
     const environmentSettingValue = authProviderConfig.get(CloudEnvironmentSettingName);
     if (environmentSettingValue === CloudEnvironmentSettingValue.ChinaCloud) {
-        return {
-            ...azureEnv.Environment.ChinaCloud,
-            isCustomCloud: false,
-        };
+        return new ExtendedEnvironment(azureEnv.Environment.ChinaCloud, false);
     }
     else if (environmentSettingValue === CloudEnvironmentSettingValue.USGovernment) {
-        return {
-            ...azureEnv.Environment.USGovernment,
-            isCustomCloud: false,
-        };
+        return new ExtendedEnvironment(azureEnv.Environment.USGovernment, false);
     }
     else if (environmentSettingValue === CloudEnvironmentSettingValue.Custom) {
         const customCloud = authProviderConfig.get(CustomEnvironmentSettingName);
         if (customCloud) {
-            return {
-                ...new azureEnv.Environment(customCloud),
-                isCustomCloud: true,
-            };
+            return new ExtendedEnvironment(customCloud, true);
         }
         throw new Error(vscode.l10n.t('The custom cloud choice is not configured. Please configure the setting `{0}.{1}`.', CustomCloudConfigurationSection, CustomEnvironmentSettingName));
     }
-    return {
-        ...azureEnv.Environment.get(azureEnv.Environment.AzureCloud.name),
-        isCustomCloud: false,
-    };
+    return new ExtendedEnvironment(azureEnv.Environment.AzureCloud, false);
 }
 /**
  * Sets the configured Azure cloud.

package/dist/esm/src/utils/dedupeSubscriptions.d.ts

@@ -0,0 +1,14 @@
+import type { AzureSubscription } from '../contracts/AzureSubscription';
+/**
+ * Deduplicates (and sorts) a list of Azure subscriptions.
+ * In short, the behavior is that the combination of account + tenant + subscriptionId will be unique.
+ * The last appearance of any duplicates will be kept. The resulting list is sorted by subscription name.
+ *
+ * Please note:
+ * - The same tenant may appear under different accounts.
+ * - The same subscriptionId may appear under different accounts that share the same tenant.
+ * - Rarely, the same subscriptionId may also appear under different accounts + different tenants.
+ *
+ * @param subscriptions The list of subscriptions to deduplicate
+ */
+export declare function dedupeSubscriptions(subscriptions: AzureSubscription[]): AzureSubscription[];

package/dist/esm/src/utils/dedupeSubscriptions.js

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Deduplicates (and sorts) a list of Azure subscriptions.
+ * In short, the behavior is that the combination of account + tenant + subscriptionId will be unique.
+ * The last appearance of any duplicates will be kept. The resulting list is sorted by subscription name.
+ *
+ * Please note:
+ * - The same tenant may appear under different accounts.
+ * - The same subscriptionId may appear under different accounts that share the same tenant.
+ * - Rarely, the same subscriptionId may also appear under different accounts + different tenants.
+ *
+ * @param subscriptions The list of subscriptions to deduplicate
+ */
+export function dedupeSubscriptions(subscriptions) {
+    const deduped = new Map();
+    for (const sub of subscriptions) {
+        deduped.set(`${sub.account.id}/${sub.tenantId}/${sub.subscriptionId}`, sub);
+    }
+    return Array.from(deduped.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+//# sourceMappingURL=dedupeSubscriptions.js.map

package/dist/esm/src/utils/getMetricsForTelemetry.d.ts

@@ -0,0 +1,32 @@
+import type { AzureSubscriptionProvider } from '../contracts/AzureSubscriptionProvider';
+/**
+ * Telemetry metrics about Azure authentication.
+ */
+export interface AzureAuthTelemetryMetrics {
+    /**
+     * The total number of accounts. This number is always accurate.
+     */
+    totalAccounts: number;
+    /**
+     * The total number of tenants. This number only includes tenants for signed-in accounts.
+     */
+    visibleTenants: number;
+    /**
+     * The total number of subscriptions, but limited to querying the first 10 account+tenants.
+     */
+    visibleSubscriptions: number;
+    /**
+     * A JSON-stringified list of subscription IDs (up to 25).
+     */
+    subscriptionIdList: string;
+    /**
+     * Whether the subscription ID list is incomplete (i.e. there were more than 25 subscriptions).
+     */
+    subscriptionIdListIsIncomplete: boolean;
+}
+/**
+ * Gets telemetry metrics about accounts, tenants, and subscriptions.
+ * @param subscriptionProvider The subscription provider to use to get the metrics.
+ * @throws A NotSignedInError if no accounts are signed in.
+ */
+export declare function getMetricsForTelemetry(subscriptionProvider: AzureSubscriptionProvider): Promise<AzureAuthTelemetryMetrics>;

package/dist/esm/src/utils/getMetricsForTelemetry.js

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Gets telemetry metrics about accounts, tenants, and subscriptions.
+ * @param subscriptionProvider The subscription provider to use to get the metrics.
+ * @throws A NotSignedInError if no accounts are signed in.
+ */
+export async function getMetricsForTelemetry(subscriptionProvider) {
+    // Get the total number of accounts (requires no web requests)
+    // Errors are deliberately not caught here, so if no accounts are signed in, this will throw
+    const accounts = await subscriptionProvider.getAccounts();
+    const numAccounts = accounts.length;
+    // Get the total number of tenants across all accounts (requires one web request per account, which is reasonable)
+    let numTenants = 0;
+    for (const account of accounts) {
+        try {
+            const tenants = await subscriptionProvider.getTenantsForAccount(account);
+            numTenants += tenants.length;
+        }
+        catch {
+            continue; // If we can't get tenants for an account, skip it instead of throwing
+        }
+    }
+    // Get as many subscriptions as we can (requires one web request per account+tenant)
+    // This is limited to the first 10 account+tenants, thus a max of 10 web requests
+    // Errors are deliberately not caught here; none are expected since at least one account is signed in
+    const subscriptions = await subscriptionProvider.getAvailableSubscriptions();
+    const numSubscriptions = subscriptions.length;
+    // Get subscription IDs (up to 25)
+    const subscriptionSet = new Set();
+    subscriptions.slice(0, 25).forEach(sub => {
+        subscriptionSet.add(sub.subscriptionId);
+    });
+    return {
+        totalAccounts: numAccounts,
+        visibleTenants: numTenants,
+        visibleSubscriptions: numSubscriptions,
+        subscriptionIdList: JSON.stringify(Array.from(subscriptionSet)),
+        subscriptionIdListIsIncomplete: subscriptions.length > 25,
+    };
+}
+//# sourceMappingURL=getMetricsForTelemetry.js.map

package/dist/esm/src/{getSessionFromVSCode.js → utils/getSessionFromVSCode.js}

@@ -3,13 +3,16 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 import * as vscode from "vscode";
-import { getConfiguredAuthProviderId, getConfiguredAzureEnv } from "./utils/configuredAzureEnv";
-import { isAuthenticationWwwAuthenticateRequest } from "./utils/isAuthenticationWwwAuthenticateRequest";
+import { getConfiguredAuthProviderId, getConfiguredAzureEnv } from "./configuredAzureEnv";
+import { isAuthenticationWwwAuthenticateRequest } from "./isAuthenticationWwwAuthenticateRequest";
 function ensureEndingSlash(value) {
     return value.endsWith('/') ? value : `${value}/`;
 }
 function getResourceScopes(scopes) {
     if (scopes === undefined || scopes === "" || scopes.length === 0) {
+        // For https://github.com/microsoft/vscode-azurefunctions/issues/3913, the default scope was changed from
+        // ~'https://management.azure.com/.default' (`AzureEnv.resourceManagerEndpointUrl`) to
+        // ~'https://management.core.windows.net/.default' (`AzureEnv.managementEndpointUrl`)
         scopes = ensureEndingSlash(getConfiguredAzureEnv().managementEndpointUrl);
     }
     const arrScopes = (Array.isArray(scopes) ? scopes : [scopes])

package/dist/esm/src/utils/getSignalForToken.d.ts

@@ -0,0 +1,7 @@
+import type * as vscode from 'vscode';
+/**
+ * Gets an AbortSignal that is tied to the given {@link vscode.CancellationToken}.
+ * @param token The token to convert
+ * @returns The {@link AbortSignal} or undefined if no token is provided
+ */
+export declare function getSignalForToken(token: vscode.CancellationToken | undefined): AbortSignal | undefined;

package/dist/esm/src/utils/getSignalForToken.js

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Gets an AbortSignal that is tied to the given {@link vscode.CancellationToken}.
+ * @param token The token to convert
+ * @returns The {@link AbortSignal} or undefined if no token is provided
+ */
+export function getSignalForToken(token) {
+    if (!token) {
+        return undefined;
+    }
+    const controller = new AbortController();
+    if (token.isCancellationRequested) {
+        controller.abort();
+    }
+    else {
+        const disposable = token.onCancellationRequested(() => {
+            disposable.dispose();
+            controller.abort();
+        });
+    }
+    return controller.signal;
+}
+//# sourceMappingURL=getSignalForToken.js.map

package/dist/esm/src/utils/map/CaselessMap.d.ts

@@ -0,0 +1,28 @@
+export declare class CaselessMap<V> implements Map<string, V> {
+    #private;
+    clear(): void;
+    delete(key: string): boolean;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void, thisArg?: any): void;
+    get(key: string): V | undefined;
+    has(key: string): boolean;
+    set(key: string, value: V): this;
+    get size(): number;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    entries(): MapIterator<[string, V]>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    keys(): MapIterator<string>;
+    values(): MapIterator<V>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    [Symbol.iterator](): MapIterator<[string, V]>;
+    readonly [Symbol.toStringTag]: string;
+    private normalizeKey;
+}

package/dist/esm/src/utils/map/CaselessMap.js

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class CaselessMap {
+    #map = new Map();
+    clear() {
+        this.#map.clear();
+    }
+    delete(key) {
+        return this.#map.delete(this.normalizeKey(key));
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Must exactly match interface
+    forEach(callbackfn, thisArg) {
+        this.#map.forEach(entry => {
+            callbackfn.call(thisArg, entry.value, entry.originalKey, this);
+        });
+    }
+    get(key) {
+        return this.#map.get(this.normalizeKey(key))?.value;
+    }
+    has(key) {
+        return this.#map.has(this.normalizeKey(key));
+    }
+    set(key, value) {
+        this.#map.set(this.normalizeKey(key), { originalKey: key, value });
+        return this;
+    }
+    get size() {
+        return this.#map.size;
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    *entries() {
+        for (const [, entry] of this.#map) {
+            yield [entry.originalKey, entry.value];
+        }
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    *keys() {
+        for (const [, entry] of this.#map) {
+            yield entry.originalKey;
+        }
+    }
+    *values() {
+        for (const [, entry] of this.#map) {
+            yield entry.value;
+        }
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = 'CaselessMap';
+    normalizeKey(key) {
+        return key.toLowerCase();
+    }
+}
+//# sourceMappingURL=CaselessMap.js.map

package/dist/esm/src/utils/map/TwoKeyCaselessMap.d.ts

@@ -0,0 +1,49 @@
+export declare class TwoKeyCaselessMap<V> implements Iterable<[string, string, V]> {
+    #private;
+    private readonly testMode;
+    constructor(testMode?: boolean);
+    clear(): void;
+    clearByFirstKey(key1: string): void;
+    clearBySecondKey(key2: string): void;
+    delete(key1: string, key2: string): boolean;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    forEach(callbackfn: (value: V, key1: string, key2: string) => void, thisArg?: any): void;
+    get(key1: string, key2: string): V | undefined;
+    has(key1: string, key2: string): boolean;
+    set(key1: string, key2: string, value: V): this;
+    get size(): number;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    entriesByFirstKey(key1: string): MapIterator<[string, V]>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    entriesBySecondKey(key2: string): MapIterator<[string, V]>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    entries(): MapIterator<[string, string, V]>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    keysByFirstKey(key1: string): MapIterator<string>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    keysBySecondKey(key2: string): MapIterator<string>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    keys(): MapIterator<[string, string]>;
+    valuesByFirstKey(key1: string): MapIterator<V>;
+    valuesBySecondKey(key2: string): MapIterator<V>;
+    values(): MapIterator<V>;
+    /**
+     * @important Keys returned **match original case**!
+     */
+    [Symbol.iterator](): MapIterator<[string, string, V]>;
+    readonly [Symbol.toStringTag]: string;
+}

package/dist/esm/src/utils/map/TwoKeyCaselessMap.js

@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { CaselessMap } from './CaselessMap';
+export class TwoKeyCaselessMap {
+    testMode;
+    #map1 = new CaselessMap(); // First map has key1 as the outer key and key2 as the inner key
+    #map2 = new CaselessMap(); // Second key map has key2 as the outer key and key1 as the inner key
+    #size = 0;
+    constructor(testMode = false) {
+        this.testMode = testMode;
+    }
+    clear() {
+        this.#map1.clear();
+        this.#map2.clear();
+        this.#size = 0;
+    }
+    clearByFirstKey(key1) {
+        const innerMap1 = this.#map1.get(key1);
+        if (!innerMap1) {
+            return;
+        }
+        // Decrement size before any deletions
+        this.#size -= innerMap1.size;
+        // Remove all entries from #map2 that reference this key1
+        innerMap1.forEach((_, key2) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- The existence of innerMap1 ensures this is non-null
+            const innerMap2 = this.#map2.get(key2);
+            innerMap2.delete(key1);
+            if (innerMap2.size === 0) {
+                this.#map2.delete(key2);
+            }
+        });
+        // Remove the entire inner map from #map1
+        this.#map1.delete(key1);
+    }
+    clearBySecondKey(key2) {
+        const innerMap2 = this.#map2.get(key2);
+        if (!innerMap2) {
+            return;
+        }
+        // Decrement size before any deletions
+        this.#size -= innerMap2.size;
+        // Remove all entries from #map1 that reference this key2
+        innerMap2.forEach((_, key1) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- The existence of innerMap2 ensures this is non-null
+            const innerMap1 = this.#map1.get(key1);
+            innerMap1.delete(key2);
+            if (innerMap1.size === 0) {
+                this.#map1.delete(key1);
+            }
+        });
+        // Remove the entire inner map from #map2
+        this.#map2.delete(key2);
+    }
+    delete(key1, key2) {
+        if (!this.has(key1, key2)) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- The has() check above ensures non-null
+        const innerMap1 = this.#map1.get(key1);
+        innerMap1.delete(key2);
+        if (innerMap1.size === 0) {
+            this.#map1.delete(key1);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- The has() check above ensures non-null
+        const innerMap2 = this.#map2.get(key2);
+        innerMap2.delete(key1);
+        if (innerMap2.size === 0) {
+            this.#map2.delete(key2);
+        }
+        this.#size--;
+        return true;
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Must exactly match interface
+    forEach(callbackfn, thisArg) {
+        this.#map1.forEach((innerMap1, key1) => {
+            innerMap1.forEach((value, key2) => {
+                callbackfn.call(thisArg, value, key1, key2);
+            });
+        });
+    }
+    get(key1, key2) {
+        return this.#map1.get(key1)?.get(key2);
+    }
+    has(key1, key2) {
+        const result1 = this.#map1.get(key1)?.has(key2);
+        if (this.testMode) {
+            const result2 = this.#map2.get(key2)?.has(key1);
+            if (!!result1 !== !!result2) {
+                throw new Error('Inconsistent state in TwoKeyCaselessMap');
+            }
+        }
+        return result1 ?? false;
+    }
+    set(key1, key2, value) {
+        const alreadyHadEntry = this.has(key1, key2);
+        let innerMap1 = this.#map1.get(key1);
+        if (!innerMap1) {
+            innerMap1 = new CaselessMap();
+            this.#map1.set(key1, innerMap1);
+        }
+        innerMap1.set(key2, value);
+        let innerMap2 = this.#map2.get(key2);
+        if (!innerMap2) {
+            innerMap2 = new CaselessMap();
+            this.#map2.set(key2, innerMap2);
+        }
+        innerMap2.set(key1, value);
+        if (!alreadyHadEntry) {
+            this.#size++;
+        }
+        return this;
+    }
+    get size() {
+        return this.#size;
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    entriesByFirstKey(key1) {
+        return this.#map1.get(key1)?.entries() ?? emptyIterator();
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    entriesBySecondKey(key2) {
+        return this.#map2.get(key2)?.entries() ?? emptyIterator();
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    *entries() {
+        for (const [key1, innerMap1] of this.#map1) {
+            for (const [key2, value] of innerMap1) {
+                yield [key1, key2, value];
+            }
+        }
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    keysByFirstKey(key1) {
+        return this.#map1.get(key1)?.keys() ?? emptyIterator();
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    keysBySecondKey(key2) {
+        return this.#map2.get(key2)?.keys() ?? emptyIterator();
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    *keys() {
+        for (const [key1, innerMap1] of this.#map1) {
+            for (const key2 of innerMap1.keys()) {
+                yield [key1, key2];
+            }
+        }
+    }
+    valuesByFirstKey(key1) {
+        return this.#map1.get(key1)?.values() ?? emptyIterator();
+    }
+    valuesBySecondKey(key2) {
+        return this.#map2.get(key2)?.values() ?? emptyIterator();
+    }
+    *values() {
+        for (const innerMap1 of this.#map1.values()) {
+            for (const value of innerMap1.values()) {
+                yield value;
+            }
+        }
+    }
+    /**
+     * @important Keys returned **match original case**!
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = 'TwoKeyCaselessMap';
+}
+function emptyIterator() {
+    return [][Symbol.iterator]();
+}
+//# sourceMappingURL=TwoKeyCaselessMap.js.map