@depup/typedoc 0.28.17-depup.0

package/dist/lib/utils-common/declarationReference.js

@@ -0,0 +1,341 @@
+/**
+ * Parser for declaration references, see the [TSDoc grammar](https://github.com/microsoft/tsdoc/blob/main/tsdoc/src/beta/DeclarationReference.grammarkdown)
+ * for reference. TypeDoc **does not** support the full grammar today. This is intentional, since the TSDoc
+ * specified grammar allows the user to construct nonsensical declaration references such as `abc![def!ghi]`
+ *
+ * @module
+ */
+export const MeaningKeywords = [
+    "class", // SymbolFlags.Class
+    "interface", // SymbolFlags.Interface
+    "type", // SymbolFlags.TypeAlias
+    "enum", // SymbolFlags.Enum
+    "namespace", // SymbolFlags.Module
+    "function", // SymbolFlags.Function
+    "var", // SymbolFlags.Variable
+    "constructor", // SymbolFlags.Constructor
+    "member", // SymbolFlags.ClassMember | SymbolFlags.EnumMember
+    "event", //
+    "call", // SymbolFlags.Signature (for __call)
+    "new", // SymbolFlags.Signature (for __new)
+    "index", // SymbolFlags.Signature (for __index)
+    "complex", // Any complex type
+    // TypeDoc specific
+    "getter",
+    "setter",
+];
+export function meaningToString(meaning) {
+    let result = "";
+    if (meaning.keyword) {
+        result += meaning.keyword;
+    }
+    else if (meaning.label) {
+        result += meaning.label;
+    }
+    if (typeof meaning.index === "number") {
+        result += `(${meaning.index})`;
+    }
+    return result;
+}
+// <TAB> <VT> <FF> <SP> <NBSP> <ZWNBSP> <USP>
+const WhiteSpace = /[\t\u2B7F\u240C \u00A0\uFEFF\p{White_Space}]/u;
+const LineTerminator = "\r\n\u2028\u2029";
+const Punctuators = "{}()[]!.#~:,";
+const FutureReservedPunctuator = "{}@";
+const NavigationPunctuator = ".#~";
+const DecimalDigit = "0123456789";
+const HexDigit = DecimalDigit + "abcdefABCDEF";
+const SingleEscapeCharacter = `'"\\bfnrtv`;
+const EscapeCharacter = SingleEscapeCharacter + DecimalDigit + "xu";
+const UserLabelStart = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_";
+const UserLabelCharacter = UserLabelStart + DecimalDigit;
+const SingleEscapeChars = {
+    "'": "'",
+    '"': '"',
+    "\\": "\\",
+    b: "\b",
+    f: "\f",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+    v: "\v",
+};
+// EscapeSequence::
+//     SingleEscapeCharacter
+//     NonEscapeCharacter
+//     `0` [lookahead != DecimalDigit]
+//     HexEscapeSequence
+//     UnicodeEscapeSequence
+function parseEscapeSequence(source, pos, end) {
+    // SingleEscapeCharacter
+    if (SingleEscapeCharacter.includes(source[pos])) {
+        return [SingleEscapeChars[source[pos]], pos + 1];
+    }
+    // NonEscapeCharacter:: SourceCharacter but not one of EscapeCharacter or LineTerminator
+    if (!(EscapeCharacter + LineTerminator).includes(source[pos])) {
+        return [source[pos], pos + 1];
+    }
+    // `0` [lookahead != DecimalDigit]
+    if (source[pos] === "0" &&
+        pos + 1 < end &&
+        !DecimalDigit.includes(source[pos + 1])) {
+        return ["\x00", pos + 1];
+    }
+    // HexEscapeSequence:: x HexDigit HexDigit
+    if (source[pos] === "x" &&
+        pos + 2 < end &&
+        HexDigit.includes(source[pos + 1]) &&
+        HexDigit.includes(source[pos + 2])) {
+        return [
+            String.fromCharCode(parseInt(source.substring(pos + 1, pos + 3), 16)),
+            pos + 3,
+        ];
+    }
+    return parseUnicodeEscapeSequence(source, pos, end);
+}
+// UnicodeEscapeSequence::
+//     `u` HexDigit HexDigit HexDigit HexDigit
+//     `u` `{` CodePoint `}`
+// CodePoint:: > |HexDigits| but only if MV of |HexDigits| ≤ 0x10FFFF
+function parseUnicodeEscapeSequence(source, pos, end) {
+    if (source[pos] !== "u" || pos + 1 >= end) {
+        return;
+    }
+    if (HexDigit.includes(source[pos + 1])) {
+        if (pos + 4 >= end ||
+            !HexDigit.includes(source[pos + 2]) ||
+            !HexDigit.includes(source[pos + 3]) ||
+            !HexDigit.includes(source[pos + 4])) {
+            return;
+        }
+        return [
+            String.fromCharCode(parseInt(source.substring(pos + 1, pos + 5), 16)),
+            pos + 5,
+        ];
+    }
+    if (source[pos + 1] === "{" &&
+        pos + 2 < end &&
+        HexDigit.includes(source[pos + 2])) {
+        let lookahead = pos + 3;
+        while (lookahead < end && HexDigit.includes(source[lookahead])) {
+            lookahead++;
+        }
+        if (lookahead >= end || source[lookahead] !== "}")
+            return;
+        const codePoint = parseInt(source.substring(pos + 2, lookahead), 16);
+        if (codePoint <= 0x10ffff) {
+            return [String.fromCodePoint(codePoint), lookahead + 1];
+        }
+    }
+}
+// String:: `"` StringCharacters? `"`
+// StringCharacters:: StringCharacter StringCharacters?
+// StringCharacter::
+//   SourceCharacter but not one of `"` or `\` or LineTerminator
+//   `\` EscapeSequence
+export function parseString(source, pos, end) {
+    let result = "";
+    if (source[pos++] !== '"')
+        return;
+    while (pos < end) {
+        if (source[pos] === '"') {
+            return [result, pos + 1];
+        }
+        if (LineTerminator.includes(source[pos]))
+            return;
+        if (source[pos] === "\\") {
+            const esc = parseEscapeSequence(source, pos + 1, end);
+            if (!esc)
+                return;
+            result += esc[0];
+            pos = esc[1];
+            continue;
+        }
+        result += source[pos++];
+    }
+}
+// ModuleSource:: String | ModuleSourceCharacters
+export function parseModuleSource(source, pos, end) {
+    if (pos >= end)
+        return;
+    if (source[pos] === '"') {
+        return parseString(source, pos, end);
+    }
+    let lookahead = pos;
+    while (lookahead < end &&
+        !('"!' + LineTerminator).includes(source[lookahead])) {
+        lookahead++;
+    }
+    if (lookahead === pos)
+        return;
+    return [source.substring(pos, lookahead), lookahead];
+}
+// SymbolReference:
+//     ComponentPath Meaning?
+//     Meaning
+export function parseSymbolReference(source, pos, end) {
+    const path = parseComponentPath(source, pos, end);
+    pos = path?.[1] ?? pos;
+    const meaning = parseMeaning(source, pos, end);
+    pos = meaning?.[1] ?? pos;
+    if (path || meaning) {
+        return [{ path: path?.[0], meaning: meaning?.[0] }, pos];
+    }
+}
+// Component::
+//     String
+//     ComponentCharacters
+//     `[` DeclarationReference `]` <--- THIS ONE IS NOT IMPLEMENTED.
+export function parseComponent(source, pos, end) {
+    if (pos < end && source[pos] === '"') {
+        return parseString(source, pos, end);
+    }
+    let lookahead = pos;
+    while (lookahead < end &&
+        !('"' +
+            Punctuators +
+            FutureReservedPunctuator +
+            LineTerminator).includes(source[lookahead]) &&
+        !WhiteSpace.test(source[lookahead])) {
+        lookahead++;
+    }
+    if (lookahead === pos)
+        return;
+    return [source.substring(pos, lookahead), lookahead];
+}
+// ComponentPath:
+//     Component
+//     ComponentPath `.` Component                      // Navigate via 'exports' of |ComponentPath|
+//     ComponentPath `#` Component                      // Navigate via 'members' of |ComponentPath|
+//     ComponentPath `~` Component                      // Navigate via 'locals' of |ComponentPath|
+export function parseComponentPath(source, pos, end) {
+    const components = [];
+    let component = parseComponent(source, pos, end);
+    if (!component)
+        return;
+    pos = component[1];
+    components.push({ navigation: ".", path: component[0] });
+    while (pos < end && NavigationPunctuator.includes(source[pos])) {
+        const navigation = source[pos];
+        pos++;
+        component = parseComponent(source, pos, end);
+        if (!component) {
+            return;
+        }
+        pos = component[1];
+        components.push({ navigation, path: component[0] });
+    }
+    return [components, pos];
+}
+// The TSDoc specification permits the first four branches of Meaning. TypeDoc adds the UserLabel
+// branch so that the @label tag can be used with this form of declaration references.
+// Meaning:
+//     `:` MeaningKeyword                            // Indicates the meaning of a symbol (i.e. ':class')
+//     `:` MeaningKeyword `(` DecimalDigits `)`      // Indicates an overloaded meaning (i.e. ':function(1)')
+//     `:` `(` DecimalDigits `)`                     // Shorthand for an overloaded meaning (i.e. `:(1)`)
+//     `:` DecimalDigits                             // Shorthand for an overloaded meaning (i.e. ':1')
+//     `:` UserLabel                                 // Indicates a user defined label via {@label CUSTOM_LABEL}
+//
+// UserLabel:
+//     UserLabelStart UserLabelCharacter*
+export function parseMeaning(source, pos, end) {
+    if (source[pos++] !== ":")
+        return;
+    const keyword = MeaningKeywords.find((kw) => pos + kw.length <= end && source.startsWith(kw, pos));
+    if (keyword) {
+        pos += keyword.length;
+    }
+    if (!keyword && UserLabelStart.includes(source[pos])) {
+        let lookahead = pos + 1;
+        while (lookahead < end &&
+            UserLabelCharacter.includes(source[lookahead])) {
+            lookahead++;
+        }
+        return [{ label: source.substring(pos, lookahead) }, lookahead];
+    }
+    if (pos + 1 < end &&
+        source[pos] === "(" &&
+        DecimalDigit.includes(source[pos + 1])) {
+        let lookahead = pos + 1;
+        while (lookahead < end && DecimalDigit.includes(source[lookahead])) {
+            lookahead++;
+        }
+        if (lookahead < end && source[lookahead] === ")") {
+            return [
+                {
+                    keyword,
+                    index: parseInt(source.substring(pos + 1, lookahead)),
+                },
+                lookahead + 1,
+            ];
+        }
+    }
+    if (!keyword && pos < end && DecimalDigit.includes(source[pos])) {
+        let lookahead = pos;
+        while (lookahead < end && DecimalDigit.includes(source[lookahead])) {
+            lookahead++;
+        }
+        return [
+            {
+                index: parseInt(source.substring(pos, lookahead)),
+            },
+            lookahead,
+        ];
+    }
+    if (keyword) {
+        return [{ keyword }, pos];
+    }
+}
+// // NOTE: The following grammar is incorrect as |SymbolReference| and |ModuleSource| have an
+// //       ambiguous parse. The correct solution is to use a cover grammar to parse
+// //       |SymbolReference| until we hit a `!` and then reinterpret the grammar.
+// DeclarationReference:
+//   [empty]
+//   SymbolReference                               // Shorthand reference to symbol
+//   ModuleSource `!`                              // Reference to a module
+//   ModuleSource `!` SymbolReference              // Reference to an export of a module
+//   ModuleSource `!` `~` SymbolReference          // Reference to a local of a module
+//   `!` SymbolReference                           // Reference to global symbol
+export function parseDeclarationReference(source, pos, end) {
+    let moduleSource;
+    let symbolReference;
+    let resolutionStart = "local";
+    let topLevelLocalReference = false;
+    const moduleSourceOrSymbolRef = parseModuleSource(source, pos, end);
+    if (moduleSourceOrSymbolRef) {
+        if (moduleSourceOrSymbolRef[1] < end &&
+            source[moduleSourceOrSymbolRef[1]] === "!") {
+            // We had a module source!
+            pos = moduleSourceOrSymbolRef[1] + 1;
+            resolutionStart = "global";
+            moduleSource = moduleSourceOrSymbolRef[0];
+            // We might be referencing a local of a module
+            if (source[pos] === "~") {
+                topLevelLocalReference = true;
+                pos++;
+            }
+        }
+    }
+    else if (source[pos] === "!") {
+        pos++;
+        resolutionStart = "global";
+    }
+    const ref = parseSymbolReference(source, pos, end);
+    if (ref) {
+        symbolReference = ref[0];
+        if (topLevelLocalReference && symbolReference.path?.length) {
+            symbolReference.path[0].navigation = "~";
+        }
+        pos = ref[1];
+    }
+    if (!moduleSource && !symbolReference)
+        return;
+    return [
+        {
+            moduleSource,
+            resolutionStart,
+            symbolReference,
+        },
+        pos,
+    ];
+}

package/dist/lib/utils-common/enum.d.ts

@@ -0,0 +1,9 @@
+export declare function getEnumFlags<T extends number>(flags: T): T[];
+export declare function removeFlag<T extends number>(flag: T, remove: T & {}): T;
+export declare function hasAllFlags(flags: number, check: number): boolean;
+export declare function hasAnyFlag(flags: number, check: number): boolean;
+export declare function debugFlags(Enum: object, flags: number): string[];
+export declare function getEnumKeys(Enum: object): string[];
+export type EnumKeys<E extends object> = {
+    [K in keyof E]: number extends E[K] ? K : never;
+}[keyof E] & {};

package/dist/lib/utils-common/enum.js

@@ -0,0 +1,27 @@
+export function getEnumFlags(flags) {
+    const result = [];
+    for (let i = 1; i <= flags; i <<= 1) {
+        if (flags & i) {
+            result.push(i);
+        }
+    }
+    return result;
+}
+// T & {} reduces inference priority
+export function removeFlag(flag, remove) {
+    return (flag & ~remove);
+}
+export function hasAllFlags(flags, check) {
+    return (flags & check) === check;
+}
+export function hasAnyFlag(flags, check) {
+    return (flags & check) !== 0;
+}
+export function debugFlags(Enum, flags) {
+    return getEnumKeys(Enum).filter((key) => (Enum[key] & flags) === Enum[key]);
+}
+// Note: String enums are not handled.
+export function getEnumKeys(Enum) {
+    const E = Enum;
+    return Object.keys(E).filter((k) => E[E[k]] === k);
+}

package/dist/lib/utils-common/events.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Intentionally very simple event emitter.
+ *
+ * @privateRemarks
+ * This is essentially a stripped down copy of EventHooks in hooks.ts.
+ */
+export declare class EventDispatcher<T extends Record<keyof T, unknown[]>> {
+    private _listeners;
+    /**
+     * Starts listening to an event.
+     * @param event the event to listen to.
+     * @param listener function to be called when an this event is emitted.
+     * @param priority optional priority to insert this hook with.
+     *  Higher priority is placed earlier in the listener array.
+     */
+    on<K extends keyof T>(event: K, listener: (this: undefined, ...args: T[K]) => void, priority?: number): void;
+    /**
+     * Stops listening to an event.
+     * @param event the event to stop listening to.
+     * @param listener the function to remove from the listener array.
+     */
+    off<K extends keyof T>(event: K, listener: (this: undefined, ...args: T[K]) => void): void;
+    /**
+     * Emits an event to all currently subscribed listeners.
+     * @param event the event to emit.
+     * @param args any arguments required for the event.
+     */
+    trigger<K extends keyof T>(event: K, ...args: T[K]): void;
+}

package/dist/lib/utils-common/events.js

@@ -0,0 +1,49 @@
+import { insertPrioritySorted } from "./array.js";
+/**
+ * Intentionally very simple event emitter.
+ *
+ * @privateRemarks
+ * This is essentially a stripped down copy of EventHooks in hooks.ts.
+ */
+export class EventDispatcher {
+    // Function is *usually* not a good type to use, but here it lets us specify stricter
+    // contracts in the methods while not casting everywhere this is used.
+    _listeners = new Map();
+    /**
+     * Starts listening to an event.
+     * @param event the event to listen to.
+     * @param listener function to be called when an this event is emitted.
+     * @param priority optional priority to insert this hook with.
+     *  Higher priority is placed earlier in the listener array.
+     */
+    on(event, listener, priority = 0) {
+        const list = (this._listeners.get(event) || []).slice();
+        insertPrioritySorted(list, { listener, priority });
+        this._listeners.set(event, list);
+    }
+    /**
+     * Stops listening to an event.
+     * @param event the event to stop listening to.
+     * @param listener the function to remove from the listener array.
+     */
+    off(event, listener) {
+        const listeners = this._listeners.get(event);
+        if (listeners) {
+            const index = listeners.findIndex((lo) => lo.listener === listener);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        }
+    }
+    /**
+     * Emits an event to all currently subscribed listeners.
+     * @param event the event to emit.
+     * @param args any arguments required for the event.
+     */
+    trigger(event, ...args) {
+        const listeners = this._listeners.get(event)?.slice() || [];
+        for (const { listener } of listeners) {
+            listener(...args);
+        }
+    }
+}

package/dist/lib/utils-common/general.d.ts

@@ -0,0 +1,40 @@
+/**
+ * This type provides a flag that can be used to turn off more lax overloads intended for
+ * plugin use only to catch type errors in the TypeDoc codebase. The prepublishOnly npm
+ * script will be used to switch this flag to false when publishing, then immediately back
+ * to true after a successful publish.
+ */
+type InternalOnly = false;
+/**
+ * Helper type to convert `T` to `F` if compiling TypeDoc with stricter types.
+ *
+ * Can be used in overloads to map a parameter type to `never`. For example, the
+ * following function will work with any string argument, but to improve the type safety
+ * of internal code, we only ever want to pass 'a' or 'b' to it. Plugins on the other
+ * hand need to be able to pass any string to it. Overloads similar to this are used
+ * in the {@link Options} class.
+ *
+ * This is also used to prevent TypeDoc code from using deprecated methods which will
+ * be removed in a future release.
+ *
+ * ```ts
+ * function over(flag: 'a' | 'b'): string
+ * // deprecated
+ * function over(flag: IfInternal<never, string>): string
+ * function over(flag: string): string { return flag }
+ * ```
+ */
+export type IfInternal<T, F> = InternalOnly extends true ? T : F;
+/**
+ * Helper type to convert `T` to `never` if compiling TypeDoc with stricter types.
+ *
+ * See {@link IfInternal} for the rationale.
+ */
+export type NeverIfInternal<T> = IfInternal<never, T>;
+/**
+ * Utility to help type checking ensure that there is no uncovered case.
+ */
+export declare function assertNever(x: never): never;
+export declare function assert(x: unknown, message?: string): asserts x;
+export declare function NonEnumerable(_cls: unknown, context: ClassFieldDecoratorContext): void;
+export {};

package/dist/lib/utils-common/general.js

@@ -0,0 +1,22 @@
+/**
+ * Utility to help type checking ensure that there is no uncovered case.
+ */
+export function assertNever(x) {
+    throw new Error(`Expected handling to cover all possible cases, but it didn't cover: ${JSON.stringify(x)}`);
+}
+export function assert(x, message = "Assertion failed") {
+    if (!x) {
+        // eslint-disable-next-line no-debugger
+        debugger;
+        throw new Error(message);
+    }
+}
+export function NonEnumerable(_cls, context) {
+    context.addInitializer(function () {
+        Object.defineProperty(this, context.name, {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    });
+}

package/dist/lib/utils-common/hooks.d.ts

@@ -0,0 +1,51 @@
+type EventHooksMomento<T extends Record<keyof T, unknown[]>, _R> = {
+    __eventHooksMomentoBrand: never;
+};
+/**
+ * Event emitter which allows listeners to return a value.
+ *
+ * This is beneficial for the themes since it allows plugins to modify the HTML output
+ * without doing unsafe text replacement.
+ *
+ * Very simple event emitter class which collects the return values of its listeners.
+ *
+ * @example
+ * ```ts
+ * const x = new EventHooks<{ a: [string] }, string>()
+ * x.on('a', a => a.repeat(123)) // ok, returns a string
+ * x.on('b', console.log) // error, 'b' is not assignable to 'a'
+ * x.on('a' a => 1) // error, returns a number but expected a string
+ * ```
+ */
+export declare class EventHooks<T extends Record<keyof T, unknown[]>, R> {
+    private _listeners;
+    /**
+     * Starts listening to an event.
+     * @param event the event to listen to.
+     * @param listener function to be called when an this event is emitted.
+     * @param order optional order to insert this hook with.
+     */
+    on<K extends keyof T>(event: K, listener: (...args: T[K]) => R, order?: number): void;
+    /**
+     * Listens to a single occurrence of an event.
+     * @param event the event to listen to.
+     * @param listener function to be called when an this event is emitted.
+     * @param order optional order to insert this hook with.
+     */
+    once<K extends keyof T>(event: K, listener: (...args: T[K]) => R, order?: number): void;
+    /**
+     * Stops listening to an event.
+     * @param event the event to stop listening to.
+     * @param listener the function to remove from the listener array.
+     */
+    off<K extends keyof T>(event: K, listener: (...args: T[K]) => R): void;
+    /**
+     * Emits an event to all currently subscribed listeners.
+     * @param event the event to emit.
+     * @param args any arguments required for the event.
+     */
+    emit<K extends keyof T>(event: K, ...args: T[K]): R[];
+    saveMomento(): EventHooksMomento<T, R>;
+    restoreMomento(momento: EventHooksMomento<T, R>): void;
+}
+export {};

package/dist/lib/utils-common/hooks.js

@@ -0,0 +1,90 @@
+import { insertOrderSorted } from "./array.js";
+const momentos = new WeakMap();
+/**
+ * Event emitter which allows listeners to return a value.
+ *
+ * This is beneficial for the themes since it allows plugins to modify the HTML output
+ * without doing unsafe text replacement.
+ *
+ * Very simple event emitter class which collects the return values of its listeners.
+ *
+ * @example
+ * ```ts
+ * const x = new EventHooks<{ a: [string] }, string>()
+ * x.on('a', a => a.repeat(123)) // ok, returns a string
+ * x.on('b', console.log) // error, 'b' is not assignable to 'a'
+ * x.on('a' a => 1) // error, returns a number but expected a string
+ * ```
+ */
+export class EventHooks {
+    // Function is *usually* not a good type to use, but here it lets us specify stricter
+    // contracts in the methods while not casting everywhere this is used.
+    _listeners = new Map();
+    /**
+     * Starts listening to an event.
+     * @param event the event to listen to.
+     * @param listener function to be called when an this event is emitted.
+     * @param order optional order to insert this hook with.
+     */
+    on(event, listener, order = 0) {
+        const list = (this._listeners.get(event) || []).slice();
+        insertOrderSorted(list, { listener, order });
+        this._listeners.set(event, list);
+    }
+    /**
+     * Listens to a single occurrence of an event.
+     * @param event the event to listen to.
+     * @param listener function to be called when an this event is emitted.
+     * @param order optional order to insert this hook with.
+     */
+    once(event, listener, order = 0) {
+        const list = (this._listeners.get(event) || []).slice();
+        insertOrderSorted(list, { listener, once: true, order });
+        this._listeners.set(event, list);
+    }
+    /**
+     * Stops listening to an event.
+     * @param event the event to stop listening to.
+     * @param listener the function to remove from the listener array.
+     */
+    off(event, listener) {
+        const listeners = this._listeners.get(event);
+        if (listeners) {
+            const index = listeners.findIndex((lo) => lo.listener === listener);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        }
+    }
+    /**
+     * Emits an event to all currently subscribed listeners.
+     * @param event the event to emit.
+     * @param args any arguments required for the event.
+     */
+    emit(event, ...args) {
+        const listeners = this._listeners.get(event)?.slice() || [];
+        this._listeners.set(event, listeners.filter(({ once }) => !once));
+        return listeners.map(({ listener }) => listener(...args));
+    }
+    saveMomento() {
+        const momento = {};
+        const save = new Map();
+        for (const [key, val] of this._listeners) {
+            save.set(key, [...val]);
+        }
+        momentos.set(momento, save);
+        return momento;
+    }
+    restoreMomento(momento) {
+        const saved = momentos.get(momento);
+        if (saved) {
+            this._listeners.clear();
+            for (const [key, val] of saved) {
+                this._listeners.set(key, [...val]);
+            }
+        }
+        else {
+            throw new Error("Momento not found.");
+        }
+    }
+}

package/dist/lib/utils-common/i18n.d.ts

@@ -0,0 +1,18 @@
+import type { TranslationProxy } from "../internationalization/internationalization.js";
+import type { TagString } from "./validation.js";
+declare const TranslatedString: unique symbol;
+export type TranslatedString = string & {
+    [TranslatedString]: true;
+};
+/**
+ * Set the available translations to be used by TypeDoc.
+ */
+export declare function setTranslations(t: Record<string, string>): void;
+/**
+ * Add the specified translations to the current translations object
+ * Any keys already specified will overwrite current keys
+ */
+export declare function addTranslations(t: Record<string, string>): void;
+export declare const i18n: TranslationProxy;
+export declare function translateTagName(tag: TagString): TranslatedString;
+export {};