@fgv/ts-utils 5.0.2 → 5.1.0-1

package/lib/packlets/collections/convertingResultMap.js

@@ -0,0 +1,213 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertingResultMap = exports.CacheInvalidatingResultMapWrapper = void 0;
+const base_1 = require("../base");
+const readOnlyConvertingResultMap_1 = require("./readOnlyConvertingResultMap");
+/**
+ * A wrapper around a mutable result map that invalidates cache entries
+ * in the parent {@link Collections.ConvertingResultMap | ConvertingResultMap} when mutations occur.
+ * @public
+ */
+class CacheInvalidatingResultMapWrapper {
+    /**
+     * Constructs a new cache-invalidating wrapper.
+     * @param inner - The inner map to wrap.
+     * @param parent - The parent converting map whose cache should be invalidated.
+     */
+    constructor(inner, parent) {
+        this._inner = inner;
+        this._parent = parent;
+    }
+    /**
+     * The number of entries in the map.
+     */
+    get size() {
+        return this._inner.size;
+    }
+    /**
+     * Adds a key/value pair to the map if the key does not already exist.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to add.
+     * @param value - The value to add.
+     * @returns The result of the add operation.
+     */
+    add(key, value) {
+        this._parent._clearCacheEntry(key);
+        return this._inner.add(key, value);
+    }
+    /**
+     * Sets a key/value pair in the map.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to set.
+     * @param value - The value to set.
+     * @returns The result of the set operation.
+     */
+    set(key, value) {
+        this._parent._clearCacheEntry(key);
+        return this._inner.set(key, value);
+    }
+    /**
+     * Updates an existing key in the map.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to update.
+     * @param value - The new value.
+     * @returns The result of the update operation.
+     */
+    update(key, value) {
+        this._parent._clearCacheEntry(key);
+        return this._inner.update(key, value);
+    }
+    /**
+     * Deletes a key from the map.
+     * Invalidates the cache entry for the key.
+     * @param key - The key to delete.
+     * @returns The result of the delete operation.
+     */
+    delete(key) {
+        this._parent._clearCacheEntry(key);
+        return this._inner.delete(key);
+    }
+    /**
+     * Gets a value from the map.
+     * @param key - The key to retrieve.
+     * @returns The result of the get operation.
+     */
+    get(key) {
+        return this._inner.get(key);
+    }
+    getOrAdd(key, valueOrFactory) {
+        const result = typeof valueOrFactory === 'function'
+            ? this._inner.getOrAdd(key, valueOrFactory)
+            : this._inner.getOrAdd(key, valueOrFactory);
+        if (result.isSuccess() && result.detail === 'added') {
+            this._parent._clearCacheEntry(key);
+        }
+        return result;
+    }
+    /**
+     * Checks if the map contains a key.
+     * @param key - The key to check.
+     * @returns `true` if the key exists, `false` otherwise.
+     */
+    has(key) {
+        return this._inner.has(key);
+    }
+    /**
+     * Clears all entries from the map.
+     * Clears the entire cache.
+     */
+    clear() {
+        this._parent._clearCache();
+        this._inner.clear();
+    }
+    /**
+     * Returns an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    entries() {
+        return this._inner.entries();
+    }
+    /**
+     * Returns an iterator over the map keys.
+     * @returns An iterator over the map keys.
+     */
+    keys() {
+        return this._inner.keys();
+    }
+    /**
+     * Returns an iterator over the map values.
+     * @returns An iterator over the map values.
+     */
+    values() {
+        return this._inner.values();
+    }
+    /**
+     * Calls a callback for each entry in the map.
+     * @param cb - The callback to call for each entry.
+     * @param thisArg - Optional `this` argument for the callback.
+     */
+    forEach(cb, thisArg) {
+        this._inner.forEach(cb, thisArg);
+    }
+    /**
+     * Gets an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    [Symbol.iterator]() {
+        return this._inner[Symbol.iterator]();
+    }
+    /**
+     * Gets a read-only version of this map.
+     * @returns A read-only version of this map.
+     */
+    toReadOnly() {
+        return this._inner.toReadOnly();
+    }
+}
+exports.CacheInvalidatingResultMapWrapper = CacheInvalidatingResultMapWrapper;
+/**
+ * A result map that wraps an inner {@link Collections.IResultMap | IResultMap} of source type
+ * and returns lazily-converted, cached values of a target type. Exposes the inner map
+ * via a {@link Collections.CacheInvalidatingResultMapWrapper | source} property that
+ * invalidates cache entries when mutations occur.
+ * @public
+ */
+class ConvertingResultMap extends readOnlyConvertingResultMap_1.ReadOnlyConvertingResultMap {
+    /**
+     * Constructs a new {@link Collections.ConvertingResultMap | ConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params) {
+        super(params);
+        this._typedInner = params.inner;
+        this.source = new CacheInvalidatingResultMapWrapper(params.inner, this);
+    }
+    /**
+     * Creates a new {@link Collections.ConvertingResultMap | ConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create(params) {
+        return (0, base_1.captureResult)(() => new ConvertingResultMap(params));
+    }
+    /**
+     * Clears a single entry from the cache.
+     * This method is public to allow the cache-invalidating wrapper to call it.
+     * @param key - The key to clear from the cache.
+     * @internal
+     */
+    _clearCacheEntry(key) {
+        super._clearCacheEntry(key);
+    }
+    /**
+     * Clears all entries from the cache.
+     * This method is public to allow the cache-invalidating wrapper to call it.
+     * @internal
+     */
+    _clearCache() {
+        super._clearCache();
+    }
+}
+exports.ConvertingResultMap = ConvertingResultMap;
+//# sourceMappingURL=convertingResultMap.js.map

package/lib/packlets/collections/index.d.ts

@@ -1,6 +1,7 @@
 import * as Utils from './utils';
 export * from './collectible';
 export * from './convertingCollector';
+export * from './convertingResultMap';
 export * from './collector';
 export * from './collectorValidator';
 export * from './convertingCollectorValidator';
@@ -8,9 +9,12 @@ export * from './validatingConvertingCollector';
 export * from './common';
 export * from './keyValueConverters';
 export * from './readonlyResultMap';
+export * from './readOnlyConvertingResultMap';
 export * from './resultMap';
 export * from './resultMapValidator';
 export * from './validatingCollector';
+export * from './validatingConvertingResultMap';
 export * from './validatingResultMap';
+export * from './aggregatedResultMap';
 export { Utils };
 //# sourceMappingURL=index.d.ts.map

package/lib/packlets/collections/index.js

@@ -62,6 +62,7 @@ const Utils = __importStar(require("./utils"));
 exports.Utils = Utils;
 __exportStar(require("./collectible"), exports);
 __exportStar(require("./convertingCollector"), exports);
+__exportStar(require("./convertingResultMap"), exports);
 __exportStar(require("./collector"), exports);
 __exportStar(require("./collectorValidator"), exports);
 __exportStar(require("./convertingCollectorValidator"), exports);
@@ -69,8 +70,11 @@ __exportStar(require("./validatingConvertingCollector"), exports);
 __exportStar(require("./common"), exports);
 __exportStar(require("./keyValueConverters"), exports);
 __exportStar(require("./readonlyResultMap"), exports);
+__exportStar(require("./readOnlyConvertingResultMap"), exports);
 __exportStar(require("./resultMap"), exports);
 __exportStar(require("./resultMapValidator"), exports);
 __exportStar(require("./validatingCollector"), exports);
+__exportStar(require("./validatingConvertingResultMap"), exports);
 __exportStar(require("./validatingResultMap"), exports);
+__exportStar(require("./aggregatedResultMap"), exports);
 //# sourceMappingURL=index.js.map

package/lib/packlets/collections/keyValueConverters.d.ts

@@ -35,10 +35,7 @@ export declare class KeyValueConverters<TK extends string = string, TV = unknown
     readonly value: Validator<TV, unknown> | Converter<TV, unknown>;
     /**
      * Constructs a new key-value validator.
-     * @param key - Required key {@link Validator | validator}, {@link Converter | converter},
-     * or {@link Conversion.ConverterFunc | converter function}.
-     * @param value - Required value {@link Validator | validator}, {@link Converter | converter},
-     * or {@link Conversion.ConverterFunc | converter function}.
+     * @param params - Key and value converters or validators.
      */
     constructor({ key, value }: IKeyValueConverterConstructorParams<TK, TV>);
     /**

package/lib/packlets/collections/keyValueConverters.js

@@ -32,10 +32,7 @@ const conversion_1 = require("../conversion");
 class KeyValueConverters {
     /**
      * Constructs a new key-value validator.
-     * @param key - Required key {@link Validator | validator}, {@link Converter | converter},
-     * or {@link Conversion.ConverterFunc | converter function}.
-     * @param value - Required value {@link Validator | validator}, {@link Converter | converter},
-     * or {@link Conversion.ConverterFunc | converter function}.
+     * @param params - Key and value converters or validators.
      */
     constructor({ key, value }) {
         this.key = typeof key === 'function' ? conversion_1.Converters.generic(key) : key;

package/lib/packlets/collections/readOnlyConvertingResultMap.d.ts

@@ -0,0 +1,153 @@
+import { DetailedResult, Result } from '../base';
+import { ILogger } from '../logging';
+import { KeyValueEntry } from './common';
+import { IReadOnlyResultMap, ResultMapForEachCb, ResultMapResultDetail } from './readonlyResultMap';
+/**
+ * A function that converts a source value to a target value.
+ * @public
+ */
+export type ConvertingResultMapValueConverter<TK extends string, TSRC, TTARGET> = (src: TSRC, key: TK) => Result<TTARGET>;
+/**
+ * Error handling behavior for conversion failures during iteration.
+ * - `'ignore'`: Silently skip failed conversions (default behavior)
+ * - `'warn'`: Log warning and skip failed conversions
+ * - `'fail'`: Throw error on first conversion failure
+ * @public
+ */
+export type ConversionErrorHandling = 'ignore' | 'warn' | 'fail';
+/**
+ * Parameters for constructing a {@link Collections.ReadOnlyConvertingResultMap | ReadOnlyConvertingResultMap}.
+ * @public
+ */
+export interface IReadOnlyConvertingResultMapConstructorParams<TK extends string, TSRC, TTARGET> {
+    /**
+     * The inner map containing source values.
+     */
+    inner: IReadOnlyResultMap<TK, TSRC>;
+    /**
+     * The converter function to transform source values to target values.
+     */
+    converter: ConvertingResultMapValueConverter<TK, TSRC, TTARGET>;
+    /**
+     * Error handling behavior for conversion failures during iteration.
+     * Defaults to `'ignore'` (silently skip failed conversions).
+     */
+    onConversionError?: ConversionErrorHandling;
+    /**
+     * Optional logger for warnings when `onConversionError` is `'warn'`.
+     */
+    logger?: ILogger;
+}
+/**
+ * A read-only result map that wraps an inner {@link Collections.IReadOnlyResultMap | IReadOnlyResultMap}
+ * of source type and returns lazily-converted, cached values of a target type.
+ * @public
+ */
+export declare class ReadOnlyConvertingResultMap<TK extends string, TSRC, TTARGET> implements IReadOnlyResultMap<TK, TTARGET> {
+    /**
+     * The inner map containing source values.
+     */
+    protected readonly _inner: IReadOnlyResultMap<TK, TSRC>;
+    /**
+     * The converter function to transform source values to target values.
+     */
+    protected readonly _converter: ConvertingResultMapValueConverter<TK, TSRC, TTARGET>;
+    /**
+     * Cache of converted target values.
+     */
+    protected readonly _cache: Map<TK, TTARGET>;
+    /**
+     * Error handling behavior for conversion failures during iteration.
+     */
+    protected readonly _onConversionError: ConversionErrorHandling;
+    /**
+     * Optional logger for warnings.
+     */
+    protected readonly _logger?: ILogger;
+    /**
+     * Constructs a new {@link Collections.ReadOnlyConvertingResultMap | ReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params: IReadOnlyConvertingResultMapConstructorParams<TK, TSRC, TTARGET>);
+    /**
+     * Creates a new {@link Collections.ReadOnlyConvertingResultMap | ReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create<TK extends string, TSRC, TTARGET>(params: IReadOnlyConvertingResultMapConstructorParams<TK, TSRC, TTARGET>): Result<ReadOnlyConvertingResultMap<TK, TSRC, TTARGET>>;
+    /**
+     * The number of entries in the map.
+     */
+    get size(): number;
+    /**
+     * Gets a converted value from the map by key.
+     * @param key - The key to retrieve.
+     * @returns `Success` with the converted value and detail `exists` if the key was found,
+     * `Failure` with detail `not-found` if the key was not found, or `Failure` with
+     * detail `invalid-value` if conversion failed.
+     */
+    get(key: TK): DetailedResult<TTARGET, ResultMapResultDetail>;
+    /**
+     * Checks if the map contains a key.
+     * @param key - The key to check.
+     * @returns `true` if the key exists, `false` otherwise.
+     */
+    has(key: TK): boolean;
+    /**
+     * Returns an iterator over the map entries with converted values.
+     * @returns An iterator over the map entries.
+     */
+    entries(): IterableIterator<KeyValueEntry<TK, TTARGET>>;
+    /**
+     * Returns an iterator over the map keys.
+     * @returns An iterator over the map keys.
+     */
+    keys(): IterableIterator<TK>;
+    /**
+     * Returns an iterator over the converted map values.
+     * @returns An iterator over the map values.
+     */
+    values(): IterableIterator<TTARGET>;
+    /**
+     * Calls a callback for each entry in the map with converted values.
+     * @param cb - The callback to call for each entry.
+     * @param thisArg - Optional `this` argument for the callback.
+     */
+    forEach(cb: ResultMapForEachCb<TK, TTARGET>, thisArg?: unknown): void;
+    /**
+     * Gets an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    [Symbol.iterator](): IterableIterator<KeyValueEntry<TK, TTARGET>>;
+    /**
+     * Gets a read-only version of this map.
+     * @returns A read-only version of this map.
+     */
+    toReadOnly(): IReadOnlyResultMap<TK, TTARGET>;
+    /**
+     * Converts a source value to a target value and caches the result.
+     * @param key - The key of the value.
+     * @param src - The source value to convert.
+     * @returns `Success` with the converted value if successful, `Failure` otherwise.
+     */
+    protected _convertAndCache(key: TK, src: TSRC): DetailedResult<TTARGET, ResultMapResultDetail>;
+    /**
+     * Gets a cached value or converts and caches a source value.
+     * Used by iterators. Handles conversion failures according to `_onConversionError`.
+     * @param key - The key of the value.
+     * @param src - The source value to convert if not cached.
+     * @returns The converted value, or `undefined` if conversion failed.
+     * @throws Error if `_onConversionError` is `'fail'` and conversion fails.
+     */
+    protected _getOrConvert(key: TK, src: TSRC): TTARGET | undefined;
+    /**
+     * Clears a single entry from the cache.
+     * @param key - The key to clear from the cache.
+     */
+    protected _clearCacheEntry(key: TK): void;
+    /**
+     * Clears all entries from the cache.
+     */
+    protected _clearCache(): void;
+}
+//# sourceMappingURL=readOnlyConvertingResultMap.d.ts.map

package/lib/packlets/collections/readOnlyConvertingResultMap.js

@@ -0,0 +1,197 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadOnlyConvertingResultMap = void 0;
+const base_1 = require("../base");
+/**
+ * A read-only result map that wraps an inner {@link Collections.IReadOnlyResultMap | IReadOnlyResultMap}
+ * of source type and returns lazily-converted, cached values of a target type.
+ * @public
+ */
+class ReadOnlyConvertingResultMap {
+    /**
+     * Constructs a new {@link Collections.ReadOnlyConvertingResultMap | ReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params) {
+        var _a;
+        this._inner = params.inner;
+        this._converter = params.converter;
+        this._cache = new Map();
+        this._onConversionError = (_a = params.onConversionError) !== null && _a !== void 0 ? _a : 'ignore';
+        this._logger = params.logger;
+    }
+    /**
+     * Creates a new {@link Collections.ReadOnlyConvertingResultMap | ReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create(params) {
+        return (0, base_1.captureResult)(() => new ReadOnlyConvertingResultMap(params));
+    }
+    /**
+     * The number of entries in the map.
+     */
+    get size() {
+        return this._inner.size;
+    }
+    /**
+     * Gets a converted value from the map by key.
+     * @param key - The key to retrieve.
+     * @returns `Success` with the converted value and detail `exists` if the key was found,
+     * `Failure` with detail `not-found` if the key was not found, or `Failure` with
+     * detail `invalid-value` if conversion failed.
+     */
+    get(key) {
+        const cached = this._cache.get(key);
+        if (cached !== undefined) {
+            return (0, base_1.succeedWithDetail)(cached, 'exists');
+        }
+        return this._inner.get(key).onSuccess((src) => {
+            return this._convertAndCache(key, src);
+        });
+    }
+    /**
+     * Checks if the map contains a key.
+     * @param key - The key to check.
+     * @returns `true` if the key exists, `false` otherwise.
+     */
+    has(key) {
+        return this._inner.has(key);
+    }
+    /**
+     * Returns an iterator over the map entries with converted values.
+     * @returns An iterator over the map entries.
+     */
+    *entries() {
+        for (const [key, src] of this._inner.entries()) {
+            const target = this._getOrConvert(key, src);
+            if (target !== undefined) {
+                yield [key, target];
+            }
+        }
+    }
+    /**
+     * Returns an iterator over the map keys.
+     * @returns An iterator over the map keys.
+     */
+    keys() {
+        return this._inner.keys();
+    }
+    /**
+     * Returns an iterator over the converted map values.
+     * @returns An iterator over the map values.
+     */
+    *values() {
+        for (const [key, src] of this._inner.entries()) {
+            const target = this._getOrConvert(key, src);
+            if (target !== undefined) {
+                yield target;
+            }
+        }
+    }
+    /**
+     * Calls a callback for each entry in the map with converted values.
+     * @param cb - The callback to call for each entry.
+     * @param thisArg - Optional `this` argument for the callback.
+     */
+    forEach(cb, thisArg) {
+        for (const [key, src] of this._inner.entries()) {
+            const target = this._getOrConvert(key, src);
+            if (target !== undefined) {
+                cb.call(thisArg, target, key, this);
+            }
+        }
+    }
+    /**
+     * Gets an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Gets a read-only version of this map.
+     * @returns A read-only version of this map.
+     */
+    toReadOnly() {
+        return this;
+    }
+    /**
+     * Converts a source value to a target value and caches the result.
+     * @param key - The key of the value.
+     * @param src - The source value to convert.
+     * @returns `Success` with the converted value if successful, `Failure` otherwise.
+     */
+    _convertAndCache(key, src) {
+        const result = this._converter(src, key);
+        if (result.isFailure()) {
+            return (0, base_1.failWithDetail)(result.message, 'invalid-value');
+        }
+        this._cache.set(key, result.value);
+        return (0, base_1.succeedWithDetail)(result.value, 'exists');
+    }
+    /**
+     * Gets a cached value or converts and caches a source value.
+     * Used by iterators. Handles conversion failures according to `_onConversionError`.
+     * @param key - The key of the value.
+     * @param src - The source value to convert if not cached.
+     * @returns The converted value, or `undefined` if conversion failed.
+     * @throws Error if `_onConversionError` is `'fail'` and conversion fails.
+     */
+    _getOrConvert(key, src) {
+        var _a;
+        const cached = this._cache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = this._converter(src, key);
+        if (result.isSuccess()) {
+            this._cache.set(key, result.value);
+            return result.value;
+        }
+        switch (this._onConversionError) {
+            case 'fail':
+                throw new Error(`Conversion failed for key '${key}': ${result.message}`);
+            case 'warn':
+                (_a = this._logger) === null || _a === void 0 ? void 0 : _a.log('warning', `Conversion failed for key '${key}': ${result.message}`);
+                break;
+        }
+        return undefined;
+    }
+    /**
+     * Clears a single entry from the cache.
+     * @param key - The key to clear from the cache.
+     */
+    _clearCacheEntry(key) {
+        this._cache.delete(key);
+    }
+    /**
+     * Clears all entries from the cache.
+     */
+    _clearCache() {
+        this._cache.clear();
+    }
+}
+exports.ReadOnlyConvertingResultMap = ReadOnlyConvertingResultMap;
+//# sourceMappingURL=readOnlyConvertingResultMap.js.map

package/lib/packlets/collections/readonlyResultMap.d.ts

@@ -18,31 +18,31 @@ export type ResultMapForEachCb<TK extends string = string, TE = unknown> = (valu
  */
 export interface IReadOnlyResultMap<TK extends string = string, TV = unknown> {
     /**
-     * {@inheritdoc Collections.ResultMap.size}
+     * {@inheritDoc Collections.ResultMap.size}
      */
     readonly size: number;
     /**
-     * {@inheritdoc Collections.ResultMap.entries}
+     * {@inheritDoc Collections.ResultMap.entries}
      */
     entries(): IterableIterator<KeyValueEntry<TK, TV>>;
     /**
-     * {@inheritdoc Collections.ResultMap.forEach}
+     * {@inheritDoc Collections.ResultMap.forEach}
      */
     forEach(cb: ResultMapForEachCb, arg?: unknown): void;
     /**
-     * {@inheritdoc Collections.ResultMap.get}
+     * {@inheritDoc Collections.ResultMap.get}
      */
     get(key: TK): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key: TK): boolean;
     /**
-     * {@inheritdoc Collections.ResultMap.keys}
+     * {@inheritDoc Collections.ResultMap.keys}
      */
     keys(): IterableIterator<TK>;
     /**
-     * {@inheritdoc Collections.ResultMap.values}
+     * {@inheritDoc Collections.ResultMap.values}
      */
     values(): IterableIterator<TV>;
     /**