@openreachtech/furo-vue 1.3.1

package/types/generated/components/atoms/FuroIcon/FuroIconContext.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Context class for FuroIcon atom.
+ *
+ * @extends {BaseFuroContext<null, Props, null>}
+ */
+export default class FuroIconContext extends BaseFuroContext<null, Props, null> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroIconContext ? X : never} T, X
+     * @override
+     * @param {FuroIconContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroIconContext ? X : never, X>(this: T, { props, componentContext, iconRegistry, }: FuroIconContextFactoryParams): InstanceType<T>;
+    /**
+     * Constructor.
+     *
+     * @param {FuroIconContextParams} params - Parameters of this constructor.
+     */
+    constructor({ props, componentContext, iconRegistry, }: FuroIconContextParams);
+    iconRegistry: import("./FuroIconRegistry.js").default;
+    /**
+     * get: the icon name, collection prefix included.
+     *
+     * @returns {string | null} Icon name such as `ph:check`, or null.
+     */
+    get name(): string | null;
+    /**
+     * get: the length of the icon's box, applied to both axes.
+     *
+     * @returns {string | number | null} A CSS length, or null to inherit the font size.
+     */
+    get size(): string | number | null;
+    /**
+     * Extract the component that draws this icon.
+     *
+     * @returns {import('./FuroIconRegistry.js').IconRenderer} Renderer component.
+     */
+    extractRendererComponent(): import("./FuroIconRegistry.js").IconRenderer;
+    /**
+     * Whether a consumer-installed renderer draws this name.
+     *
+     * @returns {boolean} Whether the name is delegated.
+     */
+    isDelegatedIcon(): boolean;
+    /**
+     * Whether the registry draws nothing for the name.
+     *
+     * @returns {boolean} Whether the name is unregistered.
+     */
+    isUnregisteredIcon(): boolean;
+    /**
+     * Extract the attributes the drawing component expects.
+     *
+     * @returns {Record<string, *>} Renderer attributes.
+     */
+    extractRendererAttributes(): Record<string, any>;
+    /**
+     * Build the attributes a consumer-installed renderer expects.
+     *
+     * @returns {{
+     *   name: string | null
+     *   size?: string | number
+     * }} Renderer attributes.
+     */
+    buildDelegatedRendererAttributes(): {
+        name: string | null;
+        size?: string | number;
+    };
+    /**
+     * Build the size attribute a consumer-installed renderer expects.
+     *
+     * @returns {{
+     *   size?: string | number
+     * }} Size attribute, omitted when no size was given.
+     */
+    buildOptionalDelegatedSizeAttribute(): {
+        size?: string | number;
+    };
+    /**
+     * Build the attributes the library's own renderer expects.
+     *
+     * @returns {{
+     *   icon: string | object | null
+     *   width?: string | number
+     *   height?: string | number
+     * }} Renderer attributes.
+     */
+    buildOfflineRendererAttributes(): {
+        icon: string | object | null;
+        width?: string | number;
+        height?: string | number;
+    };
+    /**
+     * Extract what the renderer draws, substituting a visible glyph for a name
+     * nothing resolves.
+     *
+     * @returns {string | object | null} A registered name, resolved icon data, or the fallback name.
+     */
+    extractRenderableIcon(): string | object | null;
+    /**
+     * Fail on a name nothing resolves, which the fallback glyph would otherwise leave
+     * to a visual check. Production draws the glyph instead.
+     *
+     * @param {{
+     *   icon: string | object | null
+     * }} params - Parameters of this method.
+     * @returns {void}
+     * @throws {Error} When no icon data resolves the name.
+     */
+    throwOnUnresolvedIcon({ icon, }: {
+        icon: string | object | null;
+    }): void;
+    /**
+     * Build the size attributes, omitted rather than nulled when no size was
+     * given, so the glyph keeps the renderer's `1em` default and scales with text.
+     *
+     * @returns {{
+     *   width?: string | number
+     *   height?: string | number
+     * }} Size attributes.
+     */
+    buildOptionalSizeAttributes(): {
+        width?: string | number;
+        height?: string | number;
+    };
+    /**
+     * Extract the CSS class map of the root host element.
+     *
+     * @returns {Record<string, boolean>} Class map.
+     */
+    extractRootClassNames(): Record<string, boolean>;
+    /**
+     * Whether the name resolves to no icon at all.
+     *
+     * @returns {boolean} Whether the name is unresolved.
+     */
+    isUnresolvedIcon(): boolean;
+}
+export type Props = {
+    name: string;
+    size?: string | number | null;
+};
+export type FuroIconContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams<Props> & {
+    iconRegistry: import("./FuroIconRegistry.js").default;
+};
+export type FuroIconContextFactoryParams = Omit<FuroIconContextParams, "iconRegistry"> & {
+    iconRegistry?: import("./FuroIconRegistry.js").default;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';

package/types/generated/components/atoms/FuroIcon/FuroIconRegistry.d.ts

@@ -0,0 +1,457 @@
+/**
+ * Registry of every icon name `<FuroIcon>` can draw. Resolution is offline, so
+ * recording what was registered is what makes an undrawable name detectable.
+ */
+export default class FuroIconRegistry {
+    /**
+     * Factory method.
+     *
+     * @param {{
+     *   stateReactive?: FuroIconRegistryState
+     *   iconStorage?: IconStorage
+     * }} [params] - Parameters of this factory method.
+     * @returns {FuroIconRegistry} An instance of this class.
+     */
+    static create({ stateReactive, iconStorage, }?: {
+        stateReactive?: FuroIconRegistryState;
+        iconStorage?: IconStorage;
+    }): FuroIconRegistry;
+    /**
+     * Resolve the one registry shared by every copy of this module in the realm.
+     *
+     * @returns {FuroIconRegistry} The shared registry.
+     */
+    static resolveSharedInstance(): FuroIconRegistry;
+    /**
+     * Create the shared registry, the library's own icons already registered.
+     *
+     * @returns {FuroIconRegistry} An instance of this class.
+     */
+    static createSharedInstance(): FuroIconRegistry;
+    /**
+     * Build the reactive state (registered names + the optional resolver and renderer).
+     *
+     * @returns {FuroIconRegistryState} Reactive state.
+     */
+    static buildStateReactive(): FuroIconRegistryState;
+    /**
+     * Create the bridge to the underlying renderer's icon storage.
+     *
+     * @returns {IconStorage} Storage bridge.
+     */
+    static createIconStorage(): IconStorage;
+    /**
+     * Build the set shape the underlying storage accepts, which stores nothing
+     * from a set carrying no `prefix`.
+     *
+     * @param {{
+     *   iconSet: IconSet
+     * }} params - Parameters of this method.
+     * @returns {IconSet} Storable icon set.
+     */
+    static buildStorableIconSet({ iconSet, }: {
+        iconSet: IconSet;
+    }): IconSet;
+    /**
+     * Extract the prefix a set is stored under, empty unless it carries one the
+     * storage accepts.
+     *
+     * @param {{
+     *   iconSet: IconSet
+     * }} params - Parameters of this method.
+     * @returns {string} Prefix, empty when the set carries none.
+     */
+    static extractIconSetPrefix({ iconSet, }: {
+        iconSet: IconSet;
+    }): string;
+    /**
+     * Generate what every name of a set is stored under, empty for a set carrying
+     * no prefix, so its already-prefixed keys stay verbatim.
+     *
+     * @param {{
+     *   iconSet: IconSet
+     * }} params - Parameters of this method.
+     * @returns {string} Storage prefix.
+     */
+    static generateStoragePrefix({ iconSet, }: {
+        iconSet: IconSet;
+    }): string;
+    /**
+     * Extract the full names an icon set carries, its prefix applied.
+     *
+     * @param {{
+     *   iconSet: IconSet
+     * }} params - Parameters of this method.
+     * @returns {Array<string>} Full icon names.
+     */
+    static extractIconSetNames({ iconSet, }: {
+        iconSet: IconSet;
+    }): Array<string>;
+    /**
+     * Whether the storage keeps the set at all, which it refuses wholesale over
+     * one bodyless icon or one alias pointing outside the set.
+     *
+     * @param {{
+     *   iconSet: IconSet
+     * }} params - Parameters of this method.
+     * @returns {boolean} Whether the set is storable.
+     */
+    static isStorableIconSet({ iconSet, }: {
+        iconSet: IconSet;
+    }): boolean;
+    /**
+     * Whether every dimension a shape declares is a number, which the storage
+     * demands before it keeps the set carrying it.
+     *
+     * @param {{
+     *   shape: Record<string, *>
+     *   propertyNames: Array<string>
+     * }} params - Parameters of this method.
+     * @returns {boolean} Whether every declared dimension is numeric.
+     */
+    static hasNumericDimensions({ shape, propertyNames, }: {
+        shape: Record<string, any>;
+        propertyNames: Array<string>;
+    }): boolean;
+    /**
+     * Whether an icon carries what the renderer draws.
+     *
+     * @param {{
+     *   icon: IconShape
+     * }} params - Parameters of this method.
+     * @returns {boolean} Whether the icon is drawable.
+     */
+    static isDrawableIcon({ icon, }: {
+        icon: IconShape;
+    }): boolean;
+    /**
+     * Whether a set carries a name, as an icon or as an alias.
+     *
+     * @param {{
+     *   iconSet: IconSet
+     *   name: string
+     * }} params - Parameters of this method.
+     * @returns {boolean} Whether the set carries the name.
+     */
+    static hasIconSetEntry({ iconSet, name, }: {
+        iconSet: IconSet;
+        name: string;
+    }): boolean;
+    /**
+     * Build the renderer shape the state keeps, a component unproxied so
+     * `reactive()` leaves its identity alone, a global name kept verbatim.
+     *
+     * @param {{
+     *   component: IconRenderer | null
+     * }} params - Parameters of this method.
+     * @returns {IconRenderer | null} Storable renderer.
+     */
+    static buildStorableRenderer({ component, }: {
+        component: IconRenderer | null;
+    }): IconRenderer | null;
+    /**
+     * Create the renderer that draws every registered name.
+     *
+     * @returns {import('vue').Component} The library's own renderer.
+     */
+    static createOfflineRenderer(): import("vue").Component;
+    /**
+     * Constructor.
+     *
+     * @param {{
+     *   stateReactive: FuroIconRegistryState
+     *   iconStorage: IconStorage
+     * }} params - Parameters of this constructor.
+     */
+    constructor({ stateReactive, iconStorage, }: {
+        stateReactive: FuroIconRegistryState;
+        iconStorage: IconStorage;
+    });
+    stateReactive: {
+        registeredNames: Set<string> & Omit<Set<string>, keyof Set<any>>;
+        resolver: IconResolver | null;
+        renderer: string | import("vue").FunctionalComponent<any, {}, any, {}> | {
+            new (...args: any[]): any;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } | {
+            [x: string]: any;
+            setup?: (this: void, props: import("@vue/shared").LooseRequired<any>, ctx: {
+                attrs: import("vue").Attrs;
+                slots: Readonly<{
+                    [name: string]: import("vue").Slot<any>;
+                }>;
+                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
+                expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+            }) => any;
+            name?: string;
+            template?: string | object;
+            render?: Function;
+            components?: Record<string, import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>>;
+            directives?: Record<string, import("vue").Directive<any, any, string, any>>;
+            inheritAttrs?: boolean;
+            emits?: any;
+            slots?: {};
+            expose?: string[];
+            serverPrefetch?: () => void | Promise<any>;
+            compilerOptions?: {
+                isCustomElement?: (tag: string) => boolean;
+                whitespace?: "preserve" | "condense";
+                comments?: boolean;
+                delimiters?: [string, string];
+            };
+            call?: (this: unknown, ...args: unknown[]) => never;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+            __defaults?: {};
+            compatConfig?: {
+                GLOBAL_MOUNT?: boolean | "suppress-warning";
+                GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning";
+                GLOBAL_EXTEND?: boolean | "suppress-warning";
+                GLOBAL_PROTOTYPE?: boolean | "suppress-warning";
+                GLOBAL_SET?: boolean | "suppress-warning";
+                GLOBAL_DELETE?: boolean | "suppress-warning";
+                GLOBAL_OBSERVABLE?: boolean | "suppress-warning";
+                GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning";
+                CONFIG_SILENT?: boolean | "suppress-warning";
+                CONFIG_DEVTOOLS?: boolean | "suppress-warning";
+                CONFIG_KEY_CODES?: boolean | "suppress-warning";
+                CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning";
+                CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning";
+                CONFIG_WHITESPACE?: boolean | "suppress-warning";
+                CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning";
+                INSTANCE_SET?: boolean | "suppress-warning";
+                INSTANCE_DELETE?: boolean | "suppress-warning";
+                INSTANCE_DESTROY?: boolean | "suppress-warning";
+                INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning";
+                INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning";
+                INSTANCE_CHILDREN?: boolean | "suppress-warning";
+                INSTANCE_LISTENERS?: boolean | "suppress-warning";
+                INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning";
+                INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning";
+                OPTIONS_DATA_FN?: boolean | "suppress-warning";
+                OPTIONS_DATA_MERGE?: boolean | "suppress-warning";
+                OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning";
+                OPTIONS_DESTROYED?: boolean | "suppress-warning";
+                WATCH_ARRAY?: boolean | "suppress-warning";
+                PROPS_DEFAULT_THIS?: boolean | "suppress-warning";
+                V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning";
+                CUSTOM_DIR?: boolean | "suppress-warning";
+                ATTR_FALSE_VALUE?: boolean | "suppress-warning";
+                ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning";
+                TRANSITION_CLASSES?: boolean | "suppress-warning";
+                TRANSITION_GROUP_ROOT?: boolean | "suppress-warning";
+                COMPONENT_ASYNC?: boolean | "suppress-warning";
+                COMPONENT_FUNCTIONAL?: boolean | "suppress-warning";
+                COMPONENT_V_MODEL?: boolean | "suppress-warning";
+                RENDER_FUNCTION?: boolean | "suppress-warning";
+                FILTERS?: boolean | "suppress-warning";
+                PRIVATE_APIS?: boolean | "suppress-warning";
+                MODE?: 2 | 3 | ((comp: import("vue").Component | null) => 2 | 3);
+            };
+            data?: (this: any, vm: any) => any;
+            computed?: import("vue").ComputedOptions;
+            methods?: import("vue").MethodOptions;
+            watch?: {
+                [x: string]: (string | import("vue").WatchCallback | ({
+                    handler: import("vue").WatchCallback | string;
+                } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback | ({
+                    handler: import("vue").WatchCallback | string;
+                } & import("vue").WatchOptions<boolean>))[];
+            };
+            provide?: import("vue").ComponentProvideOptions;
+            inject?: {} | string[];
+            filters?: Record<string, Function>;
+            mixins?: any[];
+            extends?: any;
+            beforeCreate?: () => any;
+            created?: () => any;
+            beforeMount?: () => any;
+            mounted?: () => any;
+            beforeUpdate?: () => any;
+            updated?: () => any;
+            activated?: () => any;
+            deactivated?: () => any;
+            beforeDestroy?: () => any;
+            beforeUnmount?: () => any;
+            destroyed?: () => any;
+            unmounted?: () => any;
+            renderTracked?: (e: import("vue").DebuggerEvent) => void;
+            renderTriggered?: (e: import("vue").DebuggerEvent) => void;
+            errorCaptured?: (err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void;
+            delimiters?: [string, string];
+            __differentiator?: string | number | symbol;
+            __isBuiltIn?: boolean;
+            __file?: string;
+            __name?: string;
+        };
+    };
+    iconStorage: IconStorage;
+    /**
+     * get: the constructor of this instance.
+     *
+     * @returns {typeof FuroIconRegistry} The constructor.
+     */
+    get Ctor(): typeof FuroIconRegistry;
+    /**
+     * Register a whole icon set, so every name it carries becomes drawable. A set
+     * the storage refuses records nothing, since none of its names would draw.
+     *
+     * @param {{
+     *   iconSet: IconSet
+     * }} params - Parameters of this method.
+     * @returns {FuroIconRegistry} For method chaining.
+     */
+    registerIconSet({ iconSet, }: {
+        iconSet: IconSet;
+    }): FuroIconRegistry;
+    /**
+     * Register one icon under its full name, prefix included. An icon with no
+     * body records nothing, since the renderer would draw nothing for it.
+     *
+     * @param {{
+     *   name: string
+     *   icon: IconShape
+     * }} params - Parameters of this method.
+     * @returns {FuroIconRegistry} For method chaining.
+     */
+    registerIcon({ name, icon, }: {
+        name: string;
+        icon: IconShape;
+    }): FuroIconRegistry;
+    /**
+     * Record names as drawable.
+     *
+     * @param {{
+     *   names: Array<string>
+     * }} params - Parameters of this method.
+     * @returns {FuroIconRegistry} For method chaining.
+     */
+    recordNames({ names, }: {
+        names: Array<string>;
+    }): FuroIconRegistry;
+    /**
+     * Install the resolver consulted for a name no registration covers.
+     *
+     * @param {{
+     *   resolver: IconResolver | null
+     * }} params - Parameters of this method.
+     * @returns {FuroIconRegistry} For method chaining.
+     */
+    useIconResolver({ resolver, }: {
+        resolver: IconResolver | null;
+    }): FuroIconRegistry;
+    /**
+     * Install the renderer for names the registry lacks, `null` to uninstall.
+     *
+     * @param {{
+     *   component: IconRenderer | null
+     * }} params - Parameters of this method.
+     * @returns {FuroIconRegistry} For method chaining.
+     */
+    useIconRenderer({ component, }: {
+        component: IconRenderer | null;
+    }): FuroIconRegistry;
+    /**
+     * Whether a renderer is installed.
+     *
+     * @returns {boolean} Whether a renderer is installed.
+     */
+    hasIconRenderer(): boolean;
+    /**
+     * Extract the installed renderer.
+     *
+     * @returns {IconRenderer | null} Renderer, or null when none is installed.
+     */
+    extractIconRenderer(): IconRenderer | null;
+    /**
+     * Extract the renderer that draws every registered name.
+     *
+     * @returns {import('vue').Component} The library's own renderer.
+     */
+    extractOfflineRenderer(): import("vue").Component;
+    /**
+     * Whether a name draws anything, whether it was registered or the installed
+     * resolver answers it.
+     *
+     * @param {{
+     *   name: string | null
+     * }} params - Parameters of this method.
+     * @returns {boolean} Whether the name resolves.
+     */
+    hasIcon({ name, }: {
+        name: string | null;
+    }): boolean;
+    /**
+     * Find what the renderer should draw for a name.
+     *
+     * @param {{
+     *   name: string | null
+     * }} params - Parameters of this method.
+     * @returns {string | IconShape | null} A registered name, resolved icon data, or null.
+     */
+    findRenderableIcon({ name, }: {
+        name: string | null;
+    }): string | IconShape | null;
+    /**
+     * Whether a name was registered, leaving the resolver unasked.
+     *
+     * @param {{
+     *   name: string | null
+     * }} params - Parameters of this method.
+     * @returns {boolean} Whether the name is registered.
+     */
+    hasRegisteredIcon({ name, }: {
+        name: string | null;
+    }): boolean;
+    /**
+     * Resolve a name through the installed resolver, holding it to the same shape
+     * registration demands, so undrawable data stays detectable as unresolved.
+     *
+     * @param {{
+     *   name: string
+     * }} params - Parameters of this method.
+     * @returns {IconShape | null} Icon data, or null when nothing resolves it.
+     */
+    resolveIcon({ name, }: {
+        name: string;
+    }): IconShape | null;
+}
+/**
+ * One icon's drawable data.
+ */
+export type IconShape = {
+    body: string;
+    width?: number;
+    height?: number;
+    [key: string]: any;
+};
+/**
+ * A set of icons sharing one prefix and one set of defaults.
+ */
+export type IconSet = {
+    prefix?: string;
+    width?: number;
+    height?: number;
+    icons: Record<string, IconShape>;
+    aliases?: Record<string, any>;
+    [key: string]: any;
+};
+export type IconResolver = (params: {
+    name: string;
+}) => IconShape | null;
+/**
+ * A renderer component, or the name one is globally registered under.
+ */
+export type IconRenderer = import("vue").Component | string;
+export type IconStorage = {
+    registerSet: (iconSet: any, storagePrefix: string) => void;
+    registerIcon: (name: string, icon: any) => void;
+};
+export type FuroIconRegistryState = import("vue").Reactive<{
+    registeredNames: Set<string>;
+    resolver: IconResolver | null;
+    renderer: IconRenderer | null;
+}>;

package/types/generated/components/atoms/FuroIcon/FuroIconifyRendererContext.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Context class for the catalogue renderer adapter, holding the one place its
+ * `name` / `size` map onto the underlying renderer's own properties.
+ *
+ * @extends {BaseFuroContext<null, Props, null>}
+ */
+export default class FuroIconifyRendererContext extends BaseFuroContext<null, Props, null> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroIconifyRendererContext ? X : never} T, X
+     * @override
+     * @param {FuroIconifyRendererContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroIconifyRendererContext ? X : never, X>(this: T, { props, componentContext, }: FuroIconifyRendererContextFactoryParams): InstanceType<T>;
+    constructor({ props, componentContext, reactiveHash, refHash, shallowRefHash, modelRefHash, }: import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams<Props, null, {}, {}, {}, {}>);
+    /**
+     * get: the icon name, collection prefix included.
+     *
+     * @returns {string | null} Icon name such as `mdi:home`, or null.
+     */
+    get name(): string | null;
+    /**
+     * get: the length of the icon's box, applied to both axes.
+     *
+     * @returns {string | number | null} A CSS length, or null to inherit the font size.
+     */
+    get size(): string | number | null;
+    /**
+     * Extract the attributes the underlying renderer expects.
+     *
+     * @returns {{
+     *   icon: string | null
+     *   width?: string | number
+     *   height?: string | number
+     * }} Renderer attributes.
+     */
+    extractRendererAttributes(): {
+        icon: string | null;
+        width?: string | number;
+        height?: string | number;
+    };
+    /**
+     * Build the size attributes, omitted rather than nulled when no size was
+     * given, so the glyph keeps the renderer's `1em` default and scales with text.
+     *
+     * @returns {{
+     *   width?: string | number
+     *   height?: string | number
+     * }} Size attributes.
+     */
+    buildOptionalSizeAttributes(): {
+        width?: string | number;
+        height?: string | number;
+    };
+}
+export type Props = {
+    name: string;
+    size?: string | number | null;
+};
+export type FuroIconifyRendererContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams<Props>;
+export type FuroIconifyRendererContextFactoryParams = FuroIconifyRendererContextParams;
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';